 |
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Animation Machine
Animation Machine
Learn more about animation machines and what you can use them for.
Animation machines are Unity components that are added to game objects. They’re mostly used in relation with animator components or joints, e.g. to react on animator IK updates or breaking joints on a game object.
An animation machine component can be added through the components menu (Makinom > Machines > Animation Machine) or the scene wizard (Add Machine > Animation Machine). A game object with an animation machine is represented in the Unity scene view by this gizmo icon:
You can learn more about machine components in general and their basic settings here.
Start Types
An animation machine is started by animation callback functions.
Animator IK
Started by animator components immediately before it updates its internal IK (inverse kinematics) system. It’s implemented in the component’s OnAnimatorIK function.
Local Start Variables
This start type will automatically initialize the following local variables.
layerIndex (int)
Stores the layer on which the IK solver is called.
Additional Start Conditions
The Animator IK start type can optionally check the layer index the OnAnimatorIK function was called from. This can be used to e.g. only start the machine when coming from a speci c layer.
Example
This start type can be used to set the positions of the IK goals and their respective weights. Use an Animator Weight node to set the position and weight of IK goals.
Animator Move
Started by animator components each frame after the state machines and the animations have been evaluated, but before Animator IK. It’s implemented in the component’s OnAnimatorMove function.
Example
This start type can be used to move a game object based on root motion. Use a Store Parameter node to store parameters from an animator controller into variables and use them in one of the various Movement nodes (e.g. a Move node) to move the game object.
Joint Break
Started when a joint attached to the machine’s game object broke. It’s implemented in the component’s OnJointBreak function. When a force that is higher than the breakForce of the joint, the joint will break o .
Local Start Variables
This start type will automatically initialize the following local variables.
breakForce (float)
Stores the break force that was applied to the joint.
Additional Start Conditions
The Joint Break start type can optionally check the break force the OnJointBreak function was called with. This can be used to e.g. only start the machine when the break force is between two de ned values.
Example
This start type can be used to animate the breaking of a joint. Use a Play Sound node to play an audio clip or spawn a particle e ect prefab with a Spawn Prefab node.
Animation Event
Started when receiving an UI or animation event with no parameter.
Animation events are added to animations – select the AnimationEvent ( ) function in the animation event.
UI events are added to UI components, e.g. add it as an event to the On Click () event list of
a Button component by selecting the AnimationMachineComponent > AnimationEvent () function.
Example
This start type can be used to play sounds at speci c points in an animation. Use a Play Sound node to play an audio clip.
Animation Event (int)
Started when receiving an UI or animation event with an int parameter.
Animation events are added to animations – select the AnimationEventInt ( int ) function in the animation event.
UI events are added to UI components, e.g. add it as an event to the On Click () event list of a Button component by selecting the AnimationMachineComponent > AnimationEventInt (int) function.
Local Start Variables
This start type will automatically initialize the following local variables.
parameter (int)
Stores the int parameter that was used by the animation event.
Additional Start Conditions
The Animation Event (int) start type can optionally check the int parameter that was used by the animation event. This can be used to e.g. only start the machine when the parameter is between two de ned values.
Example
This start type can be used to play sounds at speci c points in an animation. Use a Play Sound node to play an audio clip.
Animation Event ( oat)
Started when receiving an UI or animation event with a oat parameter.
Animation events are added to animations – select the AnimationEventFloat ( oat ) function in the animation event.
UI events are added to UI components, e.g. add it as an event to the On Click () event list of
a Button component by selecting the AnimationMachineComponent > AnimationEventFloat ( oat) function.
Local Start Variables
This start type will automatically initialize the following local variables.
parameter (float)
Stores the oat parameter that was used by the animation event.
Additional Start Conditions
The Animation Event ( oat) start type can optionally check the oat parameter that was used by the animation event. This can be used to e.g. only start the machine when the parameter is between two de ned values.
Example
This start type can be used to play sounds at speci c points in an animation. Use a Play Sound node to play an audio clip.
Animation Event (string)
Started when receiving an UI or animation event with a string parameter.
Animation events are added to animations – select the AnimationEventString ( String ) function in the animation event.
UI events are added to UI components, e.g. add it as an event to the On Click () event list of a Button component by selecting the AnimationMachineComponent > AnimationEventString (string) function.
Local Start Variables
This start type will automatically initialize the following local variables.
parameter (string)
Stores the string parameter that was used by the animation event.
Additional Start Conditions
The Animation Event (string) start type can optionally check the string parameter that was used by the animation event. This can be used to e.g. only start the machine when the parameter contains a de ned text.
Example
This start type can be used to play sounds at speci c points in an animation. Use a Play Sound node to play an audio clip.
UI Game Object
Started when receiving an UI or animation event with a game object parameter – the game object will be used as the starting object.
Animation events are added to animations – select the UIGameObject ( GameObject ) function in the animation event.
UI events are added to UI components, e.g. add an event to the On Click () event list of a Button component by selecting the AnimationMachineComponent > UIGameObject (GameObject) function.
Example
This start type can be used to play sounds at speci c points in an animation. Use a Play Sound node to play an audio clip.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Animation State Machine
Animation State Machine
Learn more about animation state machines and what you can use them for.
Animation state machines are Unity state machine behaviours that are added to animator states. They’re used in animator controllers, e.g. to react on state changes.
An animation state machine can be added to a state by selecting a state and clicking on Add Behaviour > AnimationStateMachineComponent.
You can learn more about machine components in general and their basic settings here.
Start Types
An animation state machine is started by state machine and state change callback functions.
State Machine Enter
Started when transitioning from another state machine’s state to the state’s state machine. It’s implemented in the component’s OnStateMachineEnter function.
Local Start Variables
This start type will automatically initialize the following local variables.
stateMachinePathHash (int)
Stores the full path hash of the state machine.
Additional Start Conditions
The State Machine Enter start type can optionally check the state machine’s path hash the OnStateMachineEnter function was called with. This can be used to e.g. only start the machine when the path hash matches a de ned value.
Example
This start type can be used to change an animator parameter when entering a state machine. Use a Play Mecanim Animation node to change parameters of an animator.
State Machine Exit
Started when transitioning from the state’s state machine to another state machine’s state. It’s implemented in the component’s OnStateMachineExit function.
Local Start Variables
This start type will automatically initialize the following local variables.
stateMachinePathHash (int)
Stores the full path hash of the state machine.
Additional Start Conditions
The State Machine Exit start type can optionally check the state machine’s path hash the OnStateMachineExit function was called with. This can be used to e.g. only start the machine when the path hash matches a de ned value.
Example
This start type can be used to change an animator parameter when leaving a state machine. Use a Play Mecanim Animation node to change parameters of an animator.
State Enter
Started when the state machine starts evaluating the state (i.e. when entering the state). It’s implemented in the component’s OnStateEnter function.
Local Start Variables
This start type will automatically initialize the following local variables.
layerIndex (int)
Stores the state’s layer index.
fullPathHash (int)
Stores the full path hash of the state.
shortNameHash (int)
Stores the path hash of the state.
This hash is generated using Animator.StringToHash and doesn’t include the parent layer’s name.
tagHash (int)
Stores the hash of the state’s tag.
length (float)
Stores the current duration of the state.
normalizedTime (float)
Stores the normalized time of the state.
loop (bool)
Stores if the state is looping or not.
Additional Start Conditions
The State Enter start type can optionally check the layer index the OnStateEnter function was called with. This can be used to e.g. only start the machine when called from a de ned layer.
Example
This start type can be used to play an audio clip when entering a state. Use a Play Sound
node to play an audio clip.
State Exit
Started when the state machine ends evaluating the state (i.e. when leaving the state). It’s implemented in the component’s OnStateExit function.
Local Start Variables
This start type will automatically initialize the following local variables.
layerIndex (int)
Stores the state’s layer index.
fullPathHash (int)
Stores the full path hash of the state.
shortNameHash (int)
Stores the path hash of the state.
This hash is generated using Animator.StringToHash and doesn’t include the parent layer’s name.
tagHash (int)
Stores the hash of the state’s tag.
length (float)
Stores the current duration of the state.
normalizedTime (float)
Stores the normalized time of the state.
loop (bool)
Stores if the state is looping or not.
Additional Start Conditions
The State Exit start type can optionally check the layer index the OnStateExit function was called with. This can be used to e.g. only start the machine when called from a de ned layer.
Example
This start type can be used to play an audio clip when leaving a state. Use a Play Sound
node to play an audio clip.
State IK
Started immediately before it updates the animator’s internal IK (inverse kinematics)
system but after Animator IK, when the state is active and the state’s layer has an IK pass. It’s implemented in the component’s OnStateIK function.
Local Start Variables
This start type will automatically initialize the following local variables.
layerIndex (int)
Stores the state’s layer index.
fullPathHash (int)
Stores the full path hash of the state.
shortNameHash (int)
Stores the path hash of the state.
This hash is generated using Animator.StringToHash and doesn’t include the parent layer’s name.
tagHash (int)
Stores the hash of the state’s tag.
length (float)
Stores the current duration of the state.
normalizedTime (float)
Stores the normalized time of the state.
loop (bool)
Stores if the state is looping or not.
Additional Start Conditions
The State IK start type can optionally check the layer index the OnStateIK function was called with. This can be used to e.g. only start the machine when called from a de ned layer.
Example
This start type can be used to set the positions of the IK goals and their respective weights. Use an Animator Weight node to set the position and weight IK goals.
State Move
Started each frame the state is active, after Animator Move. It’s implemented in the component’s OnStateMove function.
Local Start Variables
This start type will automatically initialize the following local variables.
layerIndex (int)
Stores the state’s layer index.
fullPathHash (int)
Stores the full path hash of the state.
shortNameHash (int)
Stores the path hash of the state.
This hash is generated using Animator.StringToHash and doesn’t include the parent layer’s name.
tagHash (int)
Stores the hash of the state’s tag.
length (float)
Stores the current duration of the state.
normalizedTime (float)
Stores the normalized time of the state.
loop (bool)
Stores if the state is looping or not.
Additional Start Conditions
The State Move start type can optionally check the layer index the OnStateMove function was called with. This can be used to e.g. only start the machine when called from a de ned layer.
Example
This start type can be used to move a game object based on root motion. Use a Store Parameter node to store parameters from the animator controller into variables and use them in one of the various Movement nodes (e.g. a Move node) to move the game object.
State Update
Started each frame the state is active, except the rst and last frame (i.e. when State Enter and State Exit are used). It’s implemented in the component’s OnStateUpdate function.
Local Start Variables
This start type will automatically initialize the following local variables.
layerIndex (int)
Stores the state’s layer index.
fullPathHash (int)
Stores the full path hash of the state.
shortNameHash (int)
Stores the path hash of the state.
This hash is generated using Animator.StringToHash and doesn’t include the parent layer’s name.
tagHash (int)
Stores the hash of the state’s tag.
length (float)
Stores the current duration of the state.
normalizedTime (float)
Stores the normalized time of the state.
loop (bool)
Stores if the state is looping or not.
Additional Start Conditions
The State Update start type can optionally check the layer index the OnStateUpdate function was called with. This can be used to e.g. only start the machine when called from a de ned layer.
Example
This start type can be used to play an audio clip when while being in a state. Use a Play Sound node to play an audio clip – additionally, you can check the local oat
variable normalizedTime (passed as start variable) to check the current play position of the state and only play the sound at speci c points.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Application Machine
Application Machine
Learn more about application machines and what you can use them for.
Application machines are Unity components that are added to game objects. They’re mostly used for reacting to application state changes, e.g. when losing focus or pausing the application/game.
An application machine component can be added through the components menu (Makinom > Machines > Application Machine) or the scene wizard (Add Machine > Application Machine). A game object with an application machine is represented in the Unity scene view by this gizmo icon:
You can learn more about machine components in general and their basic settings here.
Start Types
An application machine is started by application callback functions.
Focus Gained
Started when the application is focused. It’s implemented in the component’s OnApplicationFocus function.
Example
This start type can be used to remove a HUD that was displayed due to losing focus. Use a Call HUD node can also be used to close a HUD.
Focus Lost
Started when the application loses focus (e.g. the player clicks outside the application). It’s implemented in the component’s OnApplicationFocus function.
Example
This start type can be used to display a HUD to show the application is unfocused. Use a Call HUD node to display a HUD.
Paused
Started when the application is paused. It’s implemented in the component’s OnApplicationPause function.
Example
This start type can be used to set the time scale to 0 while the game is paused. Use a Change Time Scale node to change the time scale.
Unpaused
Started when the application resumes playing (i.e. unpaused). It’s implemented in the component’s OnApplicationPause function.
Example
This start type can be used to set the reset the time scale to 1 when continuing to play. Use a Change Time Scale node to change the time scale.
Quit
Started before the application is closed. It’s implemented in the component’s OnApplicationQuit function.
Example
This start type can be used to auto save the game before the application is closed. Use an Auto Save node to save the game to an auto save slot.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Editor Asset Sources
Asset Sources
Makinom can use assets from di erent sources, e.g. direct references or asset bundles.
Assets like prefabs, audio clips or textures, but also Makinom’s own data assets can come from di erent sources – every source has their own bene ts and drawbacks. Makinom supports assets from di erent sources and can switch between di erent sources for all assets in your project with a single button click in the Makinom editor.
Asset Sources
The following asset sources are currently available – the system can be extended by custom scripts by deriving from the BaseAssetSource<T> class. Check out the available asset source scripts to see how this can be implemented.
Reference
Uses a direct reference to the asset and stores it in the Makinom project (or event asset). This is the default and easiest way to use an asset, as it’ll be available in your built-game without any additional work.
The main drawback with direct references, especially in larger projects, is that all references stored in the Makinom project will be loaded into memory when Makinom is initialized with the game starter, as Unity will simply load all references of an asset. This can lead to long load times for the scene that contains the game starter and huge memory allocations.
Please note that most data assets you set up in the editor are not referenced by the project (unless they’re selected somewhere). Only certain special data that needs to be available at all time (e.g. input keys, UI boxes and HUDs) are directly referenced by the project and will be loaded upon initializing Makinom.
Resources
Uses assets that are stored in a Resources folder in your Unity project (needs to be somewhere in the Assets folder) and only saves the path of the asset within the folder. Everything in a Resources folder will be added to your built game. Moving or renaming an asset while it’s stored as a Resources asset will lead to losing the asset setup. If a selected asset isn’t stored in
a Resources folder, the asset eld will be reset (i.e. no selected asset).
While Unity doesn’t recommend using Resources folders (learn more about this here), it’s still an easy way to reduce load time and memory issues coming from direct references and can be useful.
Asset Bundle
Uses assets that are part of asset bundles. Selecting an asset will automatically de ne the asset name and asset bundle settings with the asset’s information. If a selected asset isn’t in an asset bundle, the asset eld will be reset (i.e. no selected asset).
The asset bundle’s path de nes where the bundle will be loaded from in the running game. Currently, asset bundles are only loaded from le, i.e. not loaded or streamed from the web, so your asset bundles need to be deployed with your game or downloaded before they’ll be available.
You can download a simple script that will build all asset bundles into the Streaming Assets path here. The script adds 2 new menu items to Unity’s Assets menu – Build AssetBundles will build all asset bundles in your project without any build option, Build AssetBundles Uncompressed will build all asset bundles uncompressed. I’d recommend building uncompressed bundles if you include them in your built game, as this increases the time needed to load them (since Unity doesn’t need to decompress them rst).
Everything in the streaming assets path will be added to your built game, so this is a good way to use asset bundles without having to worry about downloading or streaming them to get them into your game. Learn more about asset bundles, how to set them up and how to use them in the Unity manual.
Asset Settings
The asset settings can be found in Game > Game Settings in the Makinom editor. You can
de ne some basic settings here, e.g. the default path from where asset bundles will be loaded or if resources and asset bundles should be unloaded when changing scenes.
The main usage is the ability to change between di erent asset sources in your project and event assets. This allows you to e.g. use references while in development and switch to using asset bundles when getting ready to build your game for deployment. Changing asset sources in the project only changes those assets that support the used source, e.g. if an asset is part of an asset bundle, the asset eld would automatically update to use the asset bundle the asset is stored in – otherwise, the asset would stay as a reference (or whatever source it currently had).
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Audio and Music
Audio and Music
Learn more about using music, sound types, sound assignments and sound channels.
Music
Music is an important part of a game. You can set up music clips with optional in-track loop setup in Game > Music.
Beside simple playback, you can change also fade between clips and fade them in/out.
Music clips are played on music channels, you can set up default music channels in Game > Game Settings – music channels can also use an Audio Mixer Group (Unity feature) for advanced audio handling. Using multiple music channels allows you to e.g. an environmental track as well as a regular BGM track and let the player change their volumes independently.
Play in Schematics
You can change the played music clip (also stop or fade) using a Change Music node.
Music Player Components
The Music Player component, like schematic nodes, allows you to play, stop or fade music clips.
The component will use the selected clip and play setup when the scene is loaded (or the component’s game object is spawned).
Sound Types
You want to play a di erent sound depending on which game object was hit by a bullet? Sound types are an easy way to do this without having to change schematics or override audio resources.
In short, you can assign an audio clip to a sound type – by playing a sound type on a game object (e.g. in a Play Audio node), you can just play whatever audio clip is assigned to the sound type on a game object.
You can assign audio clips to sound types in Sound Templates and Sound Assignment components.
Sound types are set up in Base/Control > Sound Types.
Sound Templates
A sound template is a reusable assignment of audio clips to sound types. The templates can be used in Sound Assignment components to add the audio clips to a game object.
If you need to change the audio clip assigned to a sound type (or add additional assignments), you only need to change the sound template instead of having to change it on all prefabs or game objects that use it.
Sound templates are set up in Templates > Sound Templates.
Sound Assignment Components
A Sound Assignment component adds the audio clips assigned to sound types to a game object.
You can use a Sound Template as a basis for audio clip assignments to sound types and add additional assignments to the component directly. Adding a sound directly to the component will overrule assignments from the used template.
When playing a sound type (e.g. in a Play Audio node), the sound assignment component is used to nd the audio clip that is assigned to the sound type.
Examples
A Raycast node is used to hit game objects with a gun. The found game objects (added to a local Selected Data in the schematic) are used in a Play Sound node to play a sound type on them.
The game objects use Sound Assignment components to assign di erent audio clips to
sound types:
Hitting a water game object plays a splash sound.
Hitting a metal pipe game object plays a metallic hit sound. Hitting a wooden crate game object plays a wooden crack sound.
Depending on an equipped weapon, a di erent prefab is attached to the player. When
attacking enemies, a Play Sound node is used to play a sound type on the equipped weapon prefab.
The prefabs use Sound Assignment components to assign di erent audio clips to sound
types:
A baseball bat prefab plays a dull wooden hit sound.
A metal pipe prefab plays a metallic hit sound. A sharp sword prefab plays a slashing sound.
Sound Channels
Use sound channels to manage volumes of separate audio channels, e.g. menu sounds, dialogue and general game sounds (like damage sounds). You can set up default sound channels in Game > Game Settings – sound channels can also use an Audio Mixer Group (Unity feature) for advanced audio handling.
Sound Channel Components
The Sound Channel component can be used to drive the volume of an Audio Source component by a Makinom sound channel and use the channel’s audio mixer group.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Auto Machine
Auto Machine
Learn more about auto machines and what you can use them for.
Auto machines are Unity components that are added to game objects. They’re mostly used for initializing things (e.g. spawning prefabs when a level was loaded) or starting repeating schematics (e.g. for player or camera controls, using the Restart Schematic node).
An auto machine component can be added through the components menu (Makinom > Machines > Auto Machine) or the scene wizard (Add Machine > Auto Machine). A game object with an auto machine is represented in the Unity scene view by this gizmo icon:
You can learn more about machine components in general and their basic settings here.
Start Types
An auto machine is started when a game object is initialized/enabled or destroyed/disabled.
Start
Started when the machine’s game object or component is rst added to the scene. It’s implemented in the component’s Start function.
The start can optionally be delayed by a de ned amount of time, and repeat the execution after a de ned amount of time.
Example
This start type can be used to show a main menu when starting the game. Use a Show Dialogue node to create menus (Choice dialogue type).
Enable
Started each time when the machine’s game object or component is enabled. It’s implemented in the component’s OnEnable function.
The start can optionally be delayed by a de ned amount of time, and repeat the execution after a de ned amount of time.
Example
This start type can be used to reset variables or values of the game object each time it’s enabled. Use a Change Variables node to change variables, or use a Change Fields node to change other components’ eld values.
Disable
Started when the machine’s game object is disabled. It’s implemented in the component’s OnDisable function.
Example
This start type can be used to reenable the game object after some time. Use a Wait node to wait for a de ned amount of time and an Activate Object node to enable the game object.
Destroy
Started when the machine’s game object is destroyed. It’s implemented in the component’s OnDestroy function.
Example
This start type can be used to store the position of the game object before it’s destroyed. Use a Change Variables node to store the position of a game object into a Vector3 variable.
Level Was Loaded
Started after a new level was loaded. It’s implemented in the component’s OnLevelWasLoaded function.
The start can optionally be delayed by a de ned amount of time, and repeat the execution after a de ned amount of time.
Example
This start type can be used to reset variables on persistant game objects after loading a new scene. Game objects can be made persistant (i.e. they wont be destroyed when loading a new scene) by using a Don’t Destroy on Load node. Use a Change Variables node to change variables.
Share This Article :
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Editor Base/Control Section
Base/Control Section
The Base/Control section contains the settings related to control and basic game data.
The Game Controls sub-section contains the settings for game controls, interaction control and object selection.
You can also de ne prefabs used when spawning the player through Makinom, e.g. using a Spawn Player node or Scene Changers with Spawn Points, and components/machines that should automatically be added to the player (e.g. when using a Set Player node).
Input Keys
The Input Keys sub-section de nes the inputs that are available. There are many di erent input origins available, e.g. the Unity Input Manager, key codes, mouse/touch or gyroscope.
Custom input origins allow you to access 3rd party input solutions by using re ection. You can also create your own input classes by deriving from the BaseInputIDKeySetting class.
Learn more about this in the input keys documentation.
Sound Types
The Sound Types sub-section de nes the sound types that are available. Sound types are used by Sound Templates and Sound Assignment components to assign audio clips to a sound type.
This can be used by schematics to play an audio clip based on sound types, allowing di erent sounds to be played based on the used game object.
Learn more about this in the audio and music documentation.
Portrait Types
The Portrait Types sub-section de nes the portrait types that are available. Portrait types are used by Scene Objects and schematic actors to assign images to a portrait type.
This can be used in dialogues to display di erent portrait images for a speaker and in HUDs to display portraits of the displayed content (e.g. a scene object attached to an interaction).
Learn more about scene objects in the scene objects documentation.
Machine Types
The Machine Types sub-section de nes the machine types that are available. Machine types are used by Machine Templates and machine components to de ne the type of the machine.
This can be used to display di erent Interaction HUDs based on the machine type, e.g. display a Talk text when you can talk to an NPC and a Take text when you can pick up an item.
Learn more about machines in the machines documentation.
Global Machines
The Global Machins sub-section de nes the global machines that are available. Global machines are used to start schematics whenever needed or automatically.
Learn more in the global machines documentation.
Game Object Pools
The Game Object Pools sub-section de nes the prefabs used for pooling. You can use the de ned pools in scenes using the Pool component.
Learn more in the pooling documentation.
Prefab Savers
The Prefab Savers sub-section de nes prefabs and which data can be saved between scene changes and in save games.
Learn more in the saving game objects documentation. Editor
Share This Article :
Updated on June 30, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Advanced Topics Build Troubleshooting
Build Troubleshooting
Having problems building your project or running your built project?
See if your issue is listed here or in the Unity troubleshooting pages for your build target. If you can’t nd a solution, please contact me or post it in the community forum.
IL2CPP Code Stripping
Using the IL2CPP scripting backend will result in Unity’s compiler stripping/removing code it considers unused. While this isn’t a problem in most cases, it can result in errors due to missing code or DLL les in your built game – especially when re ection is used to access code, which is the case for most Makinom plugins.
You can prevent this by adding link.xml les to your project – they can be placed anywhere in your Assets folder (including any subfolder) and you can add multiple to your project.
The link.xml le is a simple text le that can de ne which code should or shouldn’t be stripped.
For example, to prevent anything in Makinom’s DLL les from being stripped, use a link.xml le with the following content:
<linker>
<assembly fullname="Makinom2" preserve="all"/>
<assembly fullname="Makinom2.UnityUI" preserve="all"/>
</linker>
This’ll prevent Makinom and the Unity UI module from being stripped.
Replace Makinom2.UnityUI with the name of the DLL le of the UI module you’re using if you use a di erent UI module.
Another example, to prevent a plugin from being stripped:
<linker>
<assembly fullname="YourPlugin" preserve="all"/>
</linker>
You might notice the pattern – put in the name of the DLL le (without .dll being added). You can nd more information on this topic and the link.xml syntax in the Unity manual.
iOS
If you’re building your project for iOS, you may run into one of the following problems.
You are using Unity iPhone Basic. You are not allowed to remove the Unity splash screen from your game.
To x this, change in XCode’s build settings the ‘Compress PNG les’ setting to NO and build the project again.
Ran out of trampolines of type 2
This is caused by use of generics, you have to tell the AOT compiler allocate more trampolines. To x this, change in Unity’s Player Settings > Other Settings the ‘AOT Compiler Options’ to nimt-trampolines=512. If you’re still receiving a trampoline error, increase the number, e.g. 1024.
EXC_BAD_ACCESS
This can be caused by Unity engine code being stripped when using ‘IL2CPP’ scripting backend. To x this, disable ‘Strip Engine Code’ in Unity’s PlayerSettings > Other Settings in your iOS player settings.
Content is displayed outside of masks
Go to ‘Edit > Project Settings > Player’ and enable ‘Use 24-bit Depth Bu er’ in the iOS ‘Resolution and Presentation’ settings in Unity.
You can nd information on other issues and more detailed instructions on the Unity troubleshooting page.
Share This Article :
Updated on May 21, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Scripting Code Extensions
Code Extensions
Extend Makinom’s functionality and settings with custom code.
Adding Custom Classes
You can extend many of Makinom’s type selections and settings with custom implementations by simply adding new scripts extending from a base type class and adding the EditorSettingInfo attribute to the class.
It’s best to look at Makinom’s default implementation in the source code for these kind of classes to learn how to do your custom implementation (you can see the available base types below).
EditorSettingInfo Attribute
The EditorSettingInfo attribute is required for adding custom selections in popup elds (e.g. for custom oat value types). It needs to be added to your custom class (see the examples below for a custom input ID key implementation).
It de nes the name and description of the selection.
[EditorSettingInfo("Name", "Description")]
Name
The 1st string parameter is the name of the setting.
Description
The 2nd string parameter is the description of the setting (e.g. listed in help texts).
You can optionally also de ne a di erent name to be displayed in the popup list, e.g. for separating into sub-selections using a ‘/‘.
[EditorSettingInfo("Name", "Description", "Sub Selection/Name)]
List Name (optional)
The optional 3rd string parameter uses a di erent name to display the selection in popup lists.
Use ‘/‘ to separate it into a sub-selection.
IObjectSelection Interface
Some classes are implemented as generic classes with the IObjectSelection interface as a requirement for the generic type, e.g. the bool value type.
1. public class BoolValue_YourCustomType<T> : BoolValue_BaseType<T> where T : IObjectSelect
You don’t really need to worry about this for your custom implementations – the used object selection implementation is de ned wherever your custom setting is used (e.g. in a schematic node).
The IObjectSelection interface is implemented in the following classes and is responsible for selecting context-based (game) objects.
FormulaObjectSelection
Used in formulas to select an object (e.g. user).
SchematicObjectSelection
Used in schematics to select an object (e.g. machine object).
GameObjectSelection
Used outside of formulas and schematics.
General Settings
Extend di erent functionality all across the framework.
Input ID Key
Input ID keys de ne the input origins available in input keys. Learn more about input keys in
this documentation.
You can add a custom input origin by extending from BaseInputIDKeySetting.
1. public class YourCustomOriginInputIDKeySetting : BaseInputIDKeySetting
There are already custom input origin extensions available in the Makinom extensions – e.g. see the Unity Input Action extension.
Game State Change Event
Game state change events are used by game states to automatically activate/inactivate when the event is red.
You can add a custom game state change event by extending from BaseGameStateChangeType.
1. public class YourCustomGameStateChangeType : BaseGameStateChangeType
Movement Component
Movement components are e.g. used by the Move To Interaction settings or the ORK Framework extension for moving combatants.
You can add a custom movement component selection by extending from BaseMovementComponentSetting.
1. public class YourCustomMovementComponentSetting : BaseMovementComponentSetting
Files & Assets
Extend le handling, e.g. save games or language export.
Editor Language Export
You can add custom language export/import functionality by extending from BaseLanguageExportFormat.
1. public class CustomLanguageExportFormat : BaseLanguageExportFormat
This requires using or implementing your class in Makinom’s editor namespace:
1. namespace GamingIsLove.Makinom.Editor
Asset Source
Asset selections in the editor can use assets from di erent sources, e.g. direct reference or asset bundles. Learn more about asset sources in this documentation.
You can add a custom asset source by extending from BaseAssetSource<T>.
1. public class YourCustomAssetSource<T> : BaseAssetSource<T> where T : UnityEngine.Object
T is a Unity Object, i.e. it can be any kind of asset.
Save Game File
You can add a custom save game le selection by extending from BaseSaveGameFileHandler.
1. public class YourCustomSaveGameFileHandler : BaseSaveGameFileHandler
Text File
You can add a custom text le selection (used by text nodes in schematics) by extending from BaseTextFileHandler.
1. public class YourCustomTextFileHandler : BaseTextFileHandler
Values
Extend how values are de ned or changed.
Interpolation
You can add a custom interpolation selection by extending from BaseInterpolation.
1. public class YourCustomInterpolation : BaseInterpolation
Math Function
You can add a custom math functions selection by extending from BaseMathFunction.
1. public class YourCustomMathFunction : BaseMathFunction
Float Operator
Float operators are used for oat value changes, e.g. adding, multiplying or dividing oat values.
You can add a custom oat operator by extending from BaseFloatOperator.
1. public class YourCustomFloatOperator : BaseFloatOperator
String Operator
String operators are used for string value changes, e.g. appending or replacing strings in other strings.
You can add a custom string operator by extending from BaseStringOperator.
1. public class YourCustomStringOperator : BaseStringOperator
Vector3 Operator
Vector3 operators are used for Vector3 value changes, e.g. adding or multiplying Vector3 values.
You can add a custom Vector3 operator by extending from BaseVector3Operator.
1. public class YourCustomVector3Operator : BaseVector3Operator
Bool Value Type
Bool value types are used by bool value selections.
You can add a custom bool value type by extending from BoolValue_BaseType<T>.
1. public class BoolValue_YourCustomType<T> : BoolValue_BaseType<T> where T : IObjectSelect
Float Value Type
Float value types are used by oat value selections.
You can add a custom oat value type by extending from FloatValue_BaseType<T>.
1. public class FloatValue_YourCustomType<T> : FloatValue_BaseType<T> where T : IObjectSele
String Value Type
String value types are used by string value selections.
You can add a custom string value type by extending from StringValue_BaseType<T>.
1. public class StringValue_YourCustomType<T> : StringValue_BaseType<T> where T : IObjectSe
Vector3 Value Type
Vector3 value types are used by Vector3 value selections.
You can add a custom Vector3 value type by extending from Vector3Value_BaseType<T>.
1. public class Vector3Value_YourCustomType<T> : Vector3Value_BaseType<T> where T : IObject
Conditions
Extend condition settings with custom conditions.
General Condition
General conditions are used all across the framework.
You can add a custom general condition by extending from BaseGeneralCondition<T>.
1. public class YourCustomGeneralCondition<T> : BaseGeneralCondition<T> where T : IObjectSe
Component Condition
Component conditions are used by multiple components, e.g. machine components.
You can add a custom component condition by extending from BaseComponentCondition.
1. public class YourCustomComponentCondition : BaseComponentCondition
Notify Machine Start
Notify machine starts are used by Auto Machines as noti cation start types, e.g. starting when a global variable changed.
You can add a custom notify machine start by extending from BaseNotifyMachineStart.
1. public class YourCustomNotifyMachineStart : BaseNotifyMachineStart
Schematics
Extend schematic functionality – also check out how to create custom nodes.
Actor Type
You can add a custom actor type by extending from BaseActorType.
1. public class YourCustomActorType : BaseActorType
Move Component
Unline the Movement Component above, this is used by position nodes for moving game objects via a selected method, e.g. via rigidbody or transform, or event Movement Components de ned above.
You can add a custom move component by extending from BaseMoveComponentType.
1. public class YourCustomMoveComponentType : BaseMoveComponentType
Rotate Component
Like the Move Component, this is used in movement/rotation nodes for rotating game objects. You can add a custom rotate component by extending from BaseRotateComponentType.
1. public class YourCustomRotateComponentType : BaseRotateComponentType
Raycast Selection
You can add a custom raycast selections to raycast nodes (schematics) by extending from BaseRaycastType<T>.
1. public class YourCustomRaycastType<T> : BaseRaycastType<T> where T : IObjectSelection, n
Shapecast Selection
You can add a custom shapecast selections to raycast nodes (schematics) by extending from BaseShapecastType<T>.
1. public class YourCustomShapecastType<T> : BaseShapecastType<T> where T : IObjectSelectio
Shapecheck Selection
You can add a custom shapecheck selections to raycast nodes (schematics) by extending from BaseShapecheckType<T>.
1. public class YourCustomShapecheckType<T> : BaseShapecheckType<T> where T : IObjectSelect
UI
Extend UI functionality.
HUD Click Action
HUD click actions are used to execute something when clicking on a part of a HUD, e.g. used in the HUD Click component when using the Unity UI module.
You can add a custom HUD click action type by extending from BaseHUDClickAction.
1. public class YourCustomHUDClickAction : BaseHUDClickAction
HUD Condition
HUD conditions are used to show or hide parts of a HUD based on conditions, e.g. used in the HUD Condition component when using the Unity UI module.
You can add a custom HUD condition by extending from BaseHUDCondition.
1. public class YourCustomHUDCondition : BaseHUDCondition
Navigation Bar Point
Navigation bar HUDs can display custom navigation content.
You can add a custom navigation bar point by extending from BaseNavigationBarPoint.
1. public class YourCustomNavigationBarPoint : BaseNavigationBarPoint
Tooltip Check
1. public class YourCustomTooltipCheck : BaseTooltipCheck
Tooltip HUDs can optionally be limited to de ned tooltips via tooltip checks. You can add a custom tooltip check by extending from BaseTooltipCheck.
HUD Setting
Add custom HUD settings to add your own HUD handling.
You can add a custom HUD by extending from BaseHUDSetting.
1. public class YourCustomHUDSetting : BaseHUDSetting
Input Option
Add custom input options to option dialogues.
You can add a custom input option by extending from BaseInputOption<T>.
1. public class YourCustomInputOption<T> : BaseInputOption<T> where T : IObjectSelection, n
UI Layout Type
Add custom UI layout types to UI > UI Layouts.
You can add a custom UI layout type by extending from UIBaseLayoutSettings.
1. public class UIYourCustomLayoutSettings : UIBaseLayoutSettings
Unity Wrapper
The Unity wrapper functionality allows replacing default Unity functionality. You can nd the settings in Game > Game Settings.
You can extend it with custom functionality, e.g. adding 3rd party pooling or loading screen solutions.
Instantiate
Manages how game objects are instantiated via the Unity wrapper functionality. You can nd custom implementations in the Makinom extensions.
You can add a custom instantiate function by extending from BaseInstantiateSetting.
1. public class YourCustomInstantiateSetting : BaseInstantiateSetting
Destroy
Manages how game objects are destroyed via the Unity wrapper functionality. You can nd custom implementations in the Makinom extensions.
You can add a custom destroy function by extending from BaseDestroySetting.
1. public class YourCustomDestroySetting : BaseDestroySetting
Scene Load
Manages how scenes are loaded via the Unity wrapper functionality. You can nd custom implementations in the Makinom extensions.
You can add a custom scene load function by extending from BaseLoadSceneSetting.
1. public class YourCustomLoadSceneSetting : BaseLoadSceneSetting
Random Number
Manages how random numbers are generated via the Unity wrapper functionality.
You can add a custom random number generation by extending from BaseRandomNumberSetting.
1. public class YourCustomRandomNumberSetting : BaseRandomNumberSetting
Updated on August 26, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Collision Machine
Collision Machine
Learn more about collision machines and what you can use them for.
Collision machines are Unity components that are added to game objects. They’re mostly used for game mechanics involving collisions, like a projectile hitting a target.
A collision machine component can be added through the components menu (Makinom > Machines > Collision Machine) or the scene wizard (Add Machine > Collision Machine). A game object with a collision machine is represented in the Unity scene view by this gizmo icon:
You can learn more about machine components in general and their basic settings here.
Start Types
A collision machine is started when a game object collides with the machine’s game object. This requires collider and rigidbody components on the game objects.
By default, collision machines can only be started when colliding with the player’s game object. Optionally, they can also be started by other game objects – this can further limited to game objects with a de ned name, tag or component attached.
Collision Enter
Started when another game object starts colliding with the machine’s game object. It’s implemented in the component’s OnCollisionEnter and OnCollisionEnter2D functions.
Local Start Variables
This start type will automatically initialize the following local variables.
relativeVelocity (Vector3)
Stores the relative linear velocity of the two game objects.
normal (Vector3 list)
Stores the normals of the contact points.
point (Vector3 list)
Stores the points (positions) of the contact points.
Additional Start Conditions
The Collision Enter start type can optionally be limited by a layer mask. This can be used to only start the machine when colliding with game objects of a de ned layer.
Example
This start type can be used to let an explosive barrel explode when hit by a projectile. Use a Spawn Prefab node to spawn a particle e ect prefab and a Play Sound node to play an audio clip.
Collision Stay
Started while another game object continues colliding with the machine’s game object. It’s implemented in the component’s OnCollisionStay and OnCollisionStay2D functions.
Local Start Variables
This start type will automatically initialize the following local variables.
relativeVelocity (Vector3)
Stores the relative linear velocity of the two game objects.
normal (Vector3 list)
Stores the normals of the contact points.
point (Vector3 list)
Stores the points (positions) of the contact points.
Additional Start Conditions
The Collision Stay start type can optionally be limited by a layer mask. This can be used to only start the machine when colliding with game objects of a de ned layer.
Example
This start type can be used to play particle e ects on the contact points while colliding. Use a Spawn Prefab node to spawn a particle e ect prefab, using the local Vector3 variable list point for the contact points.
Collision Exit
Started when another game object stops colliding with the machine’s game object. It’s implemented in the component’s OnCollisionExit and OnCollisionExit2D functions.
Local Start Variables
This start type will automatically initialize the following local variables.
relativeVelocity (Vector3)
Stores the relative linear velocity of the two game objects.
normal (Vector3 list)
Stores the normals of the contact points.
point (Vector3 list)
Stores the points (positions) of the contact points.
Additional Start Conditions
The Collision Stay start type can optionally be limited by a layer mask. This can be used to only start the machine when colliding with game objects of a de ned layer.
Example
This start type can be used to add force to a rigidbody after a collision. Use one of the Rigidbody nodes (e.g. a Rigidbody Explosion Force node) to add force to a game object’s rigidbody.
Particle Collision
Started when a particle collides with the machine’s game object. It’s implemented in the component’s OnParticleCollision function.
Additional Start Conditions
The Collision Stay start type can optionally be limited by a layer mask. This can be used to only start the machine when colliding with game objects of a de ned layer.
Example
This start type can be used to damage enemies or the player (i.e. reducing a health
variable) through particles. Use a Change Variables node to change the health variable.
Controller Collider Hit
Started when a character controller collides with the machine’s game object or a game object collides with the machine’s character controller – both require the character controller to perform a move in that frame. It’s implemented in the component’s
OnControllerColliderHit function.
Local Start Variables
This start type will automatically initialize the following local variables.
moveLength (float)
Stores how far the character controller has traveled before colliding.
moveDirection (Vector3)
Stores direction the characer controller was moving in when colliding.
normal (Vector3)
Stores the normal of collision point.
point (Vector3)
Stores the collision point (position).
Additional Start Conditions
The Collision Stay start type can optionally be limited by a layer mask. This can be used to only start the machine when colliding with game objects of a de ned layer.
Example
This start type can be used to push game objects out of the way of the character controller. Use one of the Rigidbody nodes (e.g. a Rigidbody Change Velocity node) to move a game object through it’s rigidbody.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Getting Started Components Overview
Components Overview
A quick overview over the components that are available in Makinom.
Since Makinom is an editor extension for Unity, this documentation assumes that you’ll know the basics of Unity, e.g. about components. If you’re looking for tutorials and learning materials on Unity, head over to their website.
Generally, you can nd Makinom’s components under Makinom in the component menu.
Controls
Control components are found in: Makinom > Controls
Collision Camera
A simple collision camera implementation, using raycasting to detect if anything is between the camera and the player and position the camera closer to the player in that case.
The collision camera can automatically be added to the camera of the scene by using Collision Camera Settings in Base/Control > Game Controls.
Interaction Controller
The interaction controller is used to interact with interaction machines using the Interact start type. It needs a collider (used as trigger) and a rigidbody component – either in 2D or 3D variants. Any interaction within the collider’s bounds will be available to interact.
Usually you’ll set up a prefab of the interaction controller and use it in the Interaction Settings in
Base/Control > Game Controls to automatically add it to the player.
No Control
This component can be used to prevent automatically adding control machines (set up in Base/Control > Game Controls) to the player or camera.
Object Changes
This component is used to get changes from a game object, e.g. speed, position changes, etc.
Using these values in other parts of Makinom (e.g. via nodes) will automatically add a component in Auto mode (recording changes for Update, Late Update and Fixed Update frames) to the used game object. If you want to only use a speci c update mode, add a component to the game object and select the mode you want.
In Auto mode, the component will return the changes according to the machine’s update type when used from a machine – otherwise, it’ll return the xed update changes when used during a Fixed Update frame and the Late Update changes in all other cases. Using a speci c update mode will only return the changes from that update mode, e.g. if the game object is moved via physics (Rigidbody components) it’s best to use the Fixed Update mode.
Simple Move
This is the Default component type of the Move Component Settings (e.g. used by the Move To Interaction settings in Base/Control > Game Controls).
You can add it to game objects to change the settings they should use.
Machines
Machine components are found in: Makinom > Machines
Machines are used to play your schematics, you can learn more about them in the machine documentation.
Scenes
Scene components are found in: Makinom > Scenes
Camera Events
Use a camera position (set up in Game > Camera Positions) when the player enters a collider (used as trigger) attached to the camera event’s game object.
Supports both 2D and 3D colliders.
Makinom Game Starter
Adds and initializes Makinom, learn more in the game starter documentation.
Music Player
Plays, fades or stops music on a music channel.
Learn more in the audio and music documentation.
Object Variables
Adds object variables to a game object, allowing to use them via the Object variable origin in schematics and other places.
Learn more about variables in the variables documentation.
Place On Ground
Places the game object on the ground. The ground is found via a raycast (as set up in the component) and places the game object at the hit spot.
Pool
Adds a game object pool to the scene, pools are set up in Base/Control > Game Object Pools.
Learn more in the pooling documentation.
Radius
Lets you de ne the radius of a game object – the radius can be used by distance checks to meassure distance between the edge/border of something instead of their position.
Scene Changer
Scene changers are used to load a new level/scene, optionally including a screen fade for the transition. The default screen fade is set up in Game > Game Settings, each scene changer can optionally overrule it with custom fades.
The new scene is loaded when the player enters a collider (used as trigger) attached to the scene changer, supports both 2D and 3D colliders. If you want to use scene changers as interactions, set up an interaction machine, either using a Load Scene node or a Use Scene Changer node to use a scene changer set up on a game object.
Scene Object
Adds scene object content information to a game object. You can add custom text codes and use conditions to determine if the scene object information is available.
Learn more in the scene object documentation.
Sound Assignment
Adds a sound assignment to a game object. You can add custom audio assignments (sound type to audio clip) to the component.
Learn more in the audio and music documentation.
Sound Channels
Links an Audio Source component to a Makinom sound channel.
Learn more in the audio and music documentation.
Spawn Point
De nes a position for spawning the player (e.g. after loading a scene via a Scene Changer).
They can also be used to spawn prefabs via schematics.
Store Terrain Changes
If you want to remember (and optionally save) terrain changes made using terrain nodes in schematics, add a Store Terrain Changes component to your terrain game object.
The Object ID you de ne (a random ID is generated when adding the component) is used to identify the data, i.e. if terrains use the same ID, they’ll share their terrain changes.
Waypoint Path
Adds a path to a game object. Waypoint paths can be used to move game objects along a path via the waypoint path nodes in schematics.
You can de ne path points and the curve/path between them.
UI
UI components are found in: Makinom > UI
Most of the UI components are related to the Unity UI module, check out the Unity UI documentation for details. I’ll only list non-Unity UI and only some special Unity UI components.
Add HUD (to Game Object)
Adds a HUD to the game object, using the game object as a user for the HUD.
No Flash
Prevents color ashes on UI components.
Unity UI Components
Some of the most used Unity UI module components, usually you’ll create your UI via the context menu in the scene hierarchy.
These components are only available when using the Unity UI module.
HUD
Used to set up HUD game objects (for prefabs) that are used by HUDs (UI > HUDs).
HUD Click
Adds a click action to part of a HUD.
HUD Condition
Adds a condition to part of a HUD, the game object (and child objects) will only be visible if the condition is valid.
UI Background
Used to set up background game objects (for prefabs) that are used by save game menus (UI > Save Game Settings).
UI Box
Used to set up UI box game objects (for prefabs) that are used by UI boxes (UI > UI Boxes).
UI Receive Cursor Events
Lets a UI box receive click focus and cursor over input events.
UI Flying Text
Used to set up ying text game objects (for prefabs) that are used by ying texts (e.g. in schematics).
Updated on January 12, 2021
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Scripting Custom Component Save Data
Custom Component Save Data
Store component data attached to a game object, keeping it between scene changes and save it with Makinom’s save game system.
This is done by implementing the IComponentSaveData interface in your component’s class.
You can also add custom save data (outside of components) – see the custom save data documentation for details.
When will the data be stored/loaded?
The game object needs to be a prefab instance registered with a prefab saver, or use a Game Object Saver component (and be part of the scene’s setup, i.e. not spawned during play). Learn more in this documentation.
The data of all components implementing the IComponentSaveData attached to a game object or any of its children will be stored when the game object is destroyed, including scene changes.
The data is loaded when returning to the scene – again, when it was saved as a prefab saver or via a Game Object Saver component.
When using ORK Framework, components attached to game objects will also be saved – see
this ORK documentation for details.
The IComponentSaveData interface
The IComponentSaveData interface extends the ISaveData interface that’s the basis for all save data in Makinom (and also used in the custom save data handling).
This interface has 3 functions (2 inherited from the ISaveData interface) that need to be implemented into your class:
GetSaveKey Function
This function returns the save key used to store the data of the component.
1. public string GetSaveKey()
The save key mustn’t contain any spaces, e.g. save key is not allowed, but save_key is allowed.
Only one component data can be stored per key, i.e. if you want to store multiple components of the same class, you should implement a save key eld to de ne a save key in the inspector of the component and return that key in the function.
SaveGame Function
This function is called when the component data is stored/saved. It returns a DataObject, which holds all the data that you want to save.
1. public DataObject SaveGame()
LoadGame Function
This function is called when a component data is loaded.
1. public void LoadGame(DataObject data)
The DataObject passed as parameter contains the data that is saved. It’s crucial to make a check for null on the data object before using it, since it could be null if no data was found for the save key – in that case, you can use the load game function to do default initialization.
Code example
Here’s a small code example on how the custom component save data functionality can be used.
{
// save key used to store different components of this class
public string saveKey = ""; 8.
9.
// save values
public bool toggle = false; 12.
13. public float number = 0;
14.
15. public string text = ""; 16.
17.
{
21. }
22.
// called when the component data is saved/stored
{
DataObject data = new DataObject(); 27.
data.Set("toggle", this.toggle);
data.Set("number", this.number);
data.Set("text", this.text);
33. }
34.
// called when the component data is loaded
public void LoadGame(DataObject data)
{
if(data != null)
{
data.Get("toggle", ref this.toggle);
data.Get("number", ref this.number);
data.Get("text", ref this.text);
43. }
44. }
45. }
Saving Complex Data
You can also save the data from classes and class arrays within your custom save game data by implementing the ISaveData interface in the class. This allows creating complex save game structures.
Naturally you can also save classes within classes, within classes … there is no depth limit. See the custom save data documentation for details.
Updated on June 30, 2022
Sitemap
Documentation Tutorials Extensions
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Scripting Custom Nodes
Custom Nodes
Learn how to write custom nodes.
Adding custom nodes to schematics or formulas doesn’t require implementing them in a plugin or Makinom’s source code – you can just add them in a script le in your Unity project.
Base Nodes
Some basics are valid for schematic and formula nodes.
Information Attributes
You need to let the editor know some details about the node. this is handled by adding attributes above the class.
[EditorHelp("Node Name", "The description of your node.", "")]
[NodeInfo("Section")]
EditorHelp
The EditorHelp attribute is used for the help text of the node and the node’s title/name. The 1st string parameter de nes the name, the 2nd de nes the description. The 3rd string parameter can be used for additional information, e.g. a link to a website with more details, it can be omitted.
NodeInfo
The NodeInfo attribute is used to de ne where the node will be added in the add node selection.
You can add the node to sub-sections by separating them with a / – and you can add multiple sections where the node should be added by using multiple string parameters. E.g.:
1. [NodeInfo("Section")]
This will place the node in Add Node > Section.
1. [NodeInfo("Section/Sub-Section")]
This will place the node in Add Node > Section > Sub-Section.
1. [NodeInfo("Section A", "Section B")]
This will place the node in Add Node > Section A and Add Node > Section B.
Editor Functions
Additionally to the attributes, there are functions that should be implemented in your node to tell the editor the info text and color of the node.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
// INFO: This returns the text displayed in the node's info area.
{
}
// INFO: This property handles the color of your node in the node editor.
{
get{ return Maki.EditorSettings.baseNodeColor;}
}
The GetNodeDetails function returns the text that is displayed in the node’s info area. The EditorColor property returns the color that is used to tint the node in the editor.
Additionally, you can create multi-slot nodes by overriding the next slot functions. See the BaseSchematicCheckNode or BaseFormulaCheckNode for examples:
{
if(index == 0)
{
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
}
else if(index == 1)
{
}
}
{
}
{
if(index == 0)
{
return this.next;
}
else if(index == 1)
{
return this.nextFail;
}
}
{
if(index == 0)
{
this.next = next;
}
else if(index == 1)
{
this.nextFail = next;
}
}
Schematic Nodes
You can create custom nodes by deriving from the BaseSchematicNode
or BaseSchematicCheckNode classes. For examples it’s best to check out the available node implementations.
Deriving from BaseSchematicNode will make it a node with a single Next slot, the connection to the next node is stored in the int eld next.
1. public class NewSchematicNode : BaseSchematicNode
Deriving from BaseSchematicCheckNode (which descends from BaseSchematicNode) will make a node with a Success and a Failed slot – the Success connection is stored in the int eld next,
the Failed connection is stored in the int eld nextFail.
1. public class NewSchematicNode : BaseSchematicCheckNode
You can also create multi-slot nodes, see above for more details. Using schematic nodes should use the schematic node namespace.
1. using GamingIsLove.Makinom.Schematics.Nodes;
Or, implement the node in the namespace (not required).
1. namespace GamingIsLove.Makinom.Schematics.Nodes
Node Execution
The most crucial part of the node is the Execute function, which will be used when the node is executed by the schematic. This function will handle whatever you want to do with your node –and it must tell the schematic which node will be executed next.
// INFO: This code will be executed when the node is executed.
public override void Execute(Schematic schematic)
{
// INFO: Don't forget to tell the schematic what to do next.
schematic.NodeFinished(this.next);
6. }
You can also execute the next node after a wait time by using the StartTime function of the schematic:
1. schematic.StartTime(5.0f, this.next);
The 1st parameter is a oat that de nes the time in seconds until executing the next node, the 2nd parameter de nes the next node’s index (int).
Example
In total, a node class can look like this:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
{
// INFO: The 'EditorHelp' attribute manages the name and description of the node. [EditorHelp("Node Name", "The description of your node.", "")]
// INFO: The 'NodeInfo' attribute manages in which section the node can be found in [NodeInfo("Section")]
{
// INFO: Place your settings here.
{
}
// INFO: This code will be executed when the node is executed.
public override void Execute(Schematic schematic)
{
// INFO: Don't forget to tell the schematic what to do next. schematic.NodeFinished(this.next);
}
// INFO: This returns the text displayed in the node's info area.
{
}
// INFO: This property handles the color of your node in the node editor.
{
get{ return Maki.EditorSettings.baseNodeColor;}
}
}
}
This node doesn’t do much, though. You can add your settings in the class and do whatever needs to be done in the Execute function.
Please note that your custom node doesn’t need to be in
the GamingIsLove.Makinom.Schematics.Nodes namespace, it can be placed in any namespace (or none at all).
Formula Nodes
You can create custom nodes by deriving from the BaseFormulaNode or BaseFormulaCheckNode classes. For examples it’s best to check out the available node implementations.
Deriving from BaseFormulaNode will make it a node with a single Next slot, the connection to the next node is stored in the int eld next.
1. public class NewFormulaNode : BaseFormulaNode
Deriving from BaseFormulaCheckNode (which descends from BaseFormulaNode) will make a node with a Success and a Failed slot – the Success connection is stored in the int eld next, the Failed connection is stored in the int eld nextFail.
1. public class NewFormulaNode : BaseFormulaCheckNode
You can also create multi-slot nodes, see above for more details. Using formula nodes should use the formula node namespace.
1. using GamingIsLove.Makinom.Formulas.Nodes;
Or, implement the node in the namespace (not required).
1. namespace GamingIsLove.Makinom.Formulas.Nodes
Node Calculation
The most crucial part of the node is the Calculate function, which will be used when the node is executed by the formula. This function will handle whatever you want to do with your node –and it must return which node (index) will be executed next.
public override int Calculate(FormulaCall call)
{
return this.next;
4. }
To change the current value of the formula, change the call‘s result ( oat value).
1. call.result += 1;
The call also has access to user and target of the formula, as well as local variables and selected data.
Example
In total, a node class can look like this:
1. using UnityEngine;
2. using System.Collections.Generic;
3.
{
// INFO: The 'EditorHelp' attribute manages the name and description of the node.
[EditorHelp("Node Name", "The description of your node.", "")]
// INFO: The 'NodeInfo' attribute manages in which section the node can be found in
[NodeInfo("Section")]
{
// INFO: Place your settings here. 13.
{
17. }
18.
// INFO: This code will be executed when the node is executed.
public override int Calculate(FormulaCall call)
{
call.result += 1;
return this.next;
24. }
25.
26.
// INFO: This returns the text displayed in the node's info area.
{
31. }
32.
// INFO: This property handles the color of your node in the node editor.
{
get { return Maki.EditorSettings.baseNodeColor; }
37. }
38. }
39. }
Th
is node doesn’t do much, it just adds 1 to the result. You can add your settings in the class
and do whatever needs to be done in the Calculate function.
Please note that your custom node doesn’t need to be in
the GamingIsLove.Makinom.Formulas.Nodes namespace, it can be placed in any namespace (or none at all).
Tip: Copy existing nodes
Instead of starting your node from scratch, copy the code of an existing node from the
source code and adjust it to your needs.
Base your custom nodes on existing nodes with a similar functionality (or elds you need) to save yourself some time.
Don’t forget to change the name of the class and the content of the EditorHelp attribute.
Updated on May 21, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Scripting Custom Save Data
Custom Save Data
Makinom allows you to add custom save data to the save game system.
Add custom save data (e.g. 3rd party product data) to Makinom save games by registering a class (e.g. a component) to the save game system. The class must implement the ISaveData interface.
The ISaveData interface
This interface has two functions that need to be implemented into your class:
1. public virtual DataObject SaveGame()
This function is called when the game is saved. It returns a DataObject, which holds all the data that you want to save.
1. public virtual void LoadGame(DataObject data)
This function is called when a save game is loaded. The DataObject passed as parameter contains the data that is saved. It’s crucial to make a check for null on the data object before using it, since it could be null if no data was found for the registered name – in that case, you can use the load game function to do default initialization.
Registering a custom save data
You need to register your class that implements the ISaveData interface with Makinom’s save game handler.
To register a class, call the following function:
1. Maki.SaveGame.RegisterCustomData(string name, ISaveData saveData, bool beforeSceneLoad);
The parameters of the function:
string name
The name used to register the custom save data.
You can only register one custom save data for per name.
Registering the same name again will replace the previously registered save data and pring a warning in the Unity console.
ISaveData saveData
An instance of the class that implements the ISaveData interface.
bool beforeSceneLoad
This ag decides if the custom save data will be loaded before (true) or after (false) the scene has been loaded when loading the save game.
If you want to unregister a class from the save game handler, you can call the following function:
1. ORK.SaveGame.UnregisterCustomData(string name, bool beforeSceneLoad);
Please note that only registered save data can be saved or loaded, i.e. you have to register your classes before saving or loading the game. This is best done in the scene you also initialize Makinom via a game starter.
Code Example
Here’s a small code example on how the custom save data functionality can be used. The example uses a component (MonoBehaviour), but you can also use similar code in other classes.
It’s crucial that the class you register to the save game handler must be alive throughout the entire game, and it’s best if you register it in the same scene where Makinom is rst initialized
with a game starter. Don’t register custom save data in a running game, this will lead to the classes not being registered if you play the game at a later time and want to load a save game.
{
public bool toggle = false; 7.
8. public float number = 0;
9.
10. public string text = ""; 11.
// register to the Makinom save game handler
{
Maki.SaveGame.RegisterCustomData("test", this, false); 16.
// keeps the component's game object alive
GameObject.DontDestroyOnLoad(this.gameObject);
19. }
20.
// called when a game is saved
{
DataObject data = new DataObject(); 25.
data.Set("toggle", this.toggle);
data.Set("number", this.number);
data.Set("text", this.text);
31. }
32.
// called when a game is loaded
// depending on the 'beforeSceneLoad' parameter of the registration,
// the function will be called either before or after loading the scene.
public virtual void LoadGame(DataObject data)
{
if(data != null)
{
data.Get("toggle", ref this.toggle);
data.Get("number", ref this.number);
data.Get("text", ref this.text);
43. }
44. }
45. }
Class within a Class
You can also save the data from classes and class arrays within your custom save game data by implementing the ISaveData interface in the class. This allows creating complex save game structures.
Naturally you can also save classes within classes, within classes … there is no depth limit.
Saving single classes
To add the data of a class to your custom save data:
1. data.Set("subClass", this.subClass.SaveGame());
To load the data of a class from your custom save data:
1. this.subClass.LoadGame(data.GetFile("subClass"));
Saving class arrays
To add the data of a class array to your custom save data:
DataObject[] arrayData = new DataObject[this.classArray.Length];
for(int i=0; i<this.classArray.Length; i++)
{
arrayData[i] = this.classArray[i].SaveGame();
5. }
6. data.Set("subClassArray", arrayData);
To load the data of a class array from your custom save data:
DataObject[] arrayData = data.GetFileArray("subClassArray");
if(arrayData != null)
{
this.classArray = new YourClass[arrayData.Length];
for(int i = 0; i < arrayData.Length; i++)
{
this.classArray[i] = new YourClass();
this.classArray[i].LoadGame(arrayData[i]);
9. }
10. }
Share This Article :
Updated on May 21, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Dialogue Importer
Dialogue Importer
Learn more about the dialogue importer.
The schematic node editor (Schematics section) o ers a tool to import multiple dialogues as a series of Show Dialogue nodes from provided text data.
Dialogue Importer
You can open the Dialogue Importer using the context menu in the schematic node editor:
Open Dialogue Importer
When dialogue nodes are created, they’ll be added the same way as adding nodes via Add Node – i.e. connected to the currently selected node/slot or at the position the context menu was called (if no node is selected).
Opening the dialogue importer will change the Makinom editor to display only the dialogue importer:
Replacing the section tabs at the top you’ll nd the dialogue importer tabs:
Import Settings Speakers Dialogues
Speakers and Dialogues is only available after processing provided text data to create dialogue information.
At the bottom, you’ll have the Cancel and Import Dialogue Nodes buttons. Cancel will close the importer without importing anything. Import Dialogue Nodes is only available after processing a text into dialogue information and imports the found dialogues as Show Dialogue nodes.
Import Settings
The import settings tab is used to de ne how and which data is used to create the dialogues.
Settings
The Default UI Box will be used as the UI box for all speakers/dialogues after processing the text. When reviewing the data in the Speakers and Dialogues tabs you’ll be able to change it for individual speakers or dialogues.
The Format setting de nes the format that will be processed. The importer comes with 2 formats:
Separator
Recognizes dialogues, speakers and choices based on de ned separator texts.
Markup
Dialogues, speakers and choices are encapsuled by identi er tags.
You can nd more information on the formats below.
The importer can be extended with custom formats by descending your class from BaseDialogueImportFormat.
The rest of the settings depend on the used format.
Processing Text
For the built-in formats, you’ll de ne the text data in a text area – e.g. copy/pasting data from a text le there.
After pasting text into the text area, it’s recommended to click on the Preprocess Text button (if available). This’ll use the processing options on the text and display the cleaned up text. E.g. using the Trim Spaces and Uni ed New Line options to remove empty spaces and a single new line character per new line (e.g. some text formats use 2, which can mess with text editing in case you want to change the text in the text area).
When you’re satis ed with the processing text, click on the Process Dialogues button. This’ll process the text and create speakers and dialogues that where found.
In case there was an issue with the text (e.g. not matching the de ned format settings), you’ll be noti ed by a warning in the Unity console.
Speakers
The speakers tab lists all of the found speakers after processing the text data.
It o ers the same settings as a Show Dialogue node’s speaker settings, e.g. using an actor or showing portraits. These settings will be used for the created nodes that use the speaker.
Dialogues
The dialogues tab lists all of the found dialogues after processing the text data.
You can de ne if and which of the found speakers will be used, as well as the message of the dialogue.
If choices where found for a dialogue, they’ll be listed as well (with their text).
Dialogues and choices can de ne the next dialogue that’ll be used after them. They’re automatically set to use the next dialogue after processing the text data. This’ll be used to create node connections when importing the Show Dialogue nodes.
Importing into the Schematic
When you’re satis ed with the speakers and dialogues, click on the Import Dialogue Nodes button at the bottom of the editor.
This’ll create a Show Dialogue node for each found dialogue, using their speaker’s settings. Additionally, this’ll save the current import settings (excluding the text that’s being processed) to reuse the next time you open the dialogue importer.
The dialogue importer will be closed after importing the nodes.
Formats
The Format setting of the Import Settings de ne which text format is used to process the text data.
The importer comes with 2 formats – Separator and Markup. You can extend the importer with custom formats.
Separator
Dialogues and their content (title, text, choices) will be recognized by de ned separator texts. It o ers the following settings:
Dialogue Separator
The text used to separate dialogues. Default setup is 3 empty lines.
Title Separator (Optional)
The text used to separate the title from the rest of the dialogue (text, choices) Default setup is ‘:‘ and a new line afterwards.
Choice Separator (Optional)
The text used to separate individual choices from the text and each other. Default setup is a new line followed by ‘>:‘.
Format Example
Here’s an example using the default setup of the Separator format.
1.
2.
3.
4.
5.
6.
7.
8.
Speaker A: Text.
>: Choice 1
>: Choice 2
Speaker B:
Text.
Markup
Dialogues and their content are encapsuled by identi er tags (e.g. ‘<dialogue>
<title>Speaker</title><message>Text</message></dialogue>‘. It o ers the following settings:
Dialogue Tags
The start and end tag that encapsule a whole dialogue (including their title, message and
choice tags).
Default setup is ‘<dialogue>’ start tag and ‘</dialogue>’ end tag.
Title Tags
The start and end tag that encapsule the title/speaker (must be within the dialogue tags, 1 per dialogue).
Default setup is ‘<title>’ start tag and ‘</title>’ end tag.
Message Tags
The start and end tag that encapsule the message (must be within the dialogue tags, 1 per dialogue).
Default setup is ‘<message>’ start tag and ‘</message>’ end tag.
Choice Tags
The start and end tag that encapsule a choice (must be within the dialogue tags, multiple per dialogue).
Default setup is ‘<choice>’ start tag and ‘</choice>’ end tag.
Format Example
Here’s an example using the default setup of the Markup format.
<dialogue>
<title>Speaker A</title>
<message>Text.</message>
<choice>Choice 1</choice>
<choice>Choice 2</choice>
</dialogue>
<dialogue>
<title>Speaker B</title>
<message>Text.</message>
</dialogue>
Custom Formats
The importer can be extended with custom formats by descending your class from BaseDialogueImportFormat.
The BaseDialogueImportFormat class can be found in the GamingIsLove.Makinom.Editor namespace.
Properties and Functions
A custom format must override 1 property and 1 function for the text processing, and can override an additional property and function for text preprocessing.
bool CanProcess
This property must be overridden.
When returning true, the text can be processed.
bool CanPreprocessText
This property is optional.
When returning true, preprocessing is available.
void PreprocessText()
This function is optional and called by the Preprocess Text button. Only needed when overriding CanPreprocessText.
DialogueImportContent ProcessText()
This function must be overridden and is called by the Process Dialogues button.
You will process your text data here and return a DialogueImportContent class instance with the speakers and dialogues that where found.
Example Code
Here’s a code example for a custom format:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
{
{
// return 'true' if processing is possible, otherwise 'false'
// e.g. check if text or file is available to process
}
{
// return 'true' if prerocessing is available, otherwise 'false'
}
{
// preprocessing
// used by the preprocess text button
}
{
DialogueImportContent content = new DialogueImportContent();
// process data and create speaker/dialogue content
}
}
For details on how to create the DialogueImportContent and ll it with content, please check out the code for the built-in formats.
Updated on February 22, 2023
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Editor Editor Section
Editor Section
The Editor section contains mostly settings and informations related to the Makinom editor.
About
The About sub-section displays information about your current Makinom version and contains links to resources (e.g. tutorials or the community) and allows changing the current project or creating a new project.
Editor Settings
The Editor Settings sub-section contains settings for the Makinom editor’s layout and usability. You can also export editor help texts (CSV) and select a translated help text le (also CSV).
Backups
The Backups sub-section is used to de ne the number of backups that are kept and allows restoring backups.
Each time you save in the Makinom editor (and having Create Backup enabled in the save
con rmation), the last saved state is stored as a backup. Backups will package everything in the Makinom data folder (Assets/Gaming Is Love/_Data/) into a unitypackage le.
Restoring a backup has to be done using the Makinom editor, as otherwise it might come to Unity GUID con icts that can damage your project.
Variables
The Variables sub-section lists the variable keys that have already been de ned in the Makinom editor, schematics and scenes. You can also scan the settings for any new variable keys.
Scanning the schematics will also show the schematics that use a variable key (needs to be re-scanned when opening the editor again).
These variable keys will be available for selection in variable elds by using the drop-down button on the right side of the eld. You can also de ne variable keys to make them available in selections when they haven’t been used yet. It is not required to de ne variable keys here – it’s just used to give you an overview of the already used variable keys.
Learn more about variables here.
Replace Variable Keys
You can replace variable keys in the whole project, e.g. if you have a typo or want to re ect functionality changes in variable keys this is a quick and easy way to change variable keys.
Replacing the variable key in settings, scenes, prefabs and schematics can be enabled/disabled separately.
Plugins
The Plugins sub-section allows managing plugins for Makinom. Plugins can be used to add content and store custom settings in the Makinom project asset without changing the source code of Makinom.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me
fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Getting Started First Steps
First Steps
You’ve just discovered Makinom, now what?
Since Makinom is an editor extension for Unity, this documentation assumes that you’ll know the basics of Unity. If you’re looking for tutorials and learning materials on Unity, head over to their website.
Importing Makinom
Importing Makinom into your Unity project works like importing any other asset. Depending on the used Unity version, you can import it from the Asset Store window or the Unity Package Manager.
If you’ve got Makinom as a unitypackage le or want to import an extension or plugin for Makinom (e.g. a new UI module) from a unitypackage le, just drag the le into your Unity window and drop it over the Project tab to start the import process.
Makinom will import it’s core functionality and editor (in form of DLL les), the Unity UI module (also in form of DLL les) and gizmo icons for components and data assets.
UI Modules
Makinom comes with the Unity UI module as part of the standard import.
If you don’t want to use it you can skip importing it by disabling the UI module DLL les in the import window:
Assets/Gaming Is Love/Makinom 2/DLL/Makinom2.UnityUI.dll Assets/Gaming Is Love/Makinom 2/DLL/Editor/Makinom2Editor.UnityUI.dll
Opening Makinom
Once imported, you can open the Makinom editor via Unity’s menu: Window > Makinom
Open multiple Makinom editor windows via: Window > Makinom (Multi-Window)
This can be useful if you want to compare settings side-by-side or open multiple schematics.
Alternatively, you can also open the Makinom editor via keyboard shortcuts (displayed beside the Unity menu items). The shortcuts will depending on the operating system you’re working on, e.g. in Windows you can open Makinom via Ctr + Alt + M and Ctrl + Alt + Shift + M (for multi-window use).
Learn more in the Makinom editor documentation.
First Opening
The rst time you open the Makinom editor in a Unity project will automatically create 2 assets in Makinom’s data folder: Assets/Gaming Is Love/_Data/
Project.asset
This is your Makinom project asset, it’ll be used by Game Starters to initialize Makinom in your running game.
It holds some project settings and references.
EditorData.asset
This is a purely editor-related asset and is not used in a running game.
It holds only editor data, e.g. the drag area sizes, variable key references or the list of last opened schematics.
The project asset will remain blank/empty until you save in the Makinom editor (which will also save additional data assets).
Selecting a UI System
One of the rst things you should do after importing Makinom is selecting the UI system you want to use. While Makinom comes with the Unity UI module, it doesn’t have it selected in a new project.
Go to UI > UI System in the editor and select the UI module you want to use in the UI System Type setting.
Changing the UI system will prompt a con rmation dialogue:
Using a di erent UI system will cause UI related settings to change, discarding previous setup. This is mainly the case in UI boxes and HUDs, where part of their setup depends on the used UI system, but can also impact the setup of UI related schematic nodes.
Learn more about the UI system here.
First Save
The rst time saving will create additional assets in sub-folders of Assets/Gaming Is Love/_Data/.
The individual settings of list content (e.g. input keys or UI boxes) are saved in their individual data assets. E.g. each input key will have it’s own data asset in the Input Key sub-folder.
To save the settings, click on the Save Settings button in the bottom right of the Makinom editor window. This’ll show you the changes that will be saved and o er some additional options (more on them below).
Since it’s the rst save, it’ll show a long list, since everything is new.
Learn more about saving settings in the Makinom editor documentation.
Scene Wizard
Makinom’s scene wizard is a small window to help you add Makinom game objects or components to your scenes.
Open it using the Unity menu: Window > Makinom Scene Wizard
You can open the scene wizard via a keyboard shortcut, e.g. in Windows: Ctrl + Alt + W
The scene wizard allows you to create new game objects with already added Makinom components (e.g. music players, scene changers, etc.), add components and machines to selected game objects, create new camera positions by using a scene camera and a game object as references, test formulas using 2 game objects in your scene (for position related mechanics) and add a game starter to your scene.
The scene wizard can also display help texts from Makinom settings you hover over. E.g. help texts from inspectors can be displayed that way without having the Makinom editor opened.
Extension Manager
The extension manager can be used to browse, download and import available extensions (e.g. plugins, custom nodes, other scripts or schematics) for Makinom.
Open it using the Unity Menu: Window > Makinom Extension Manager
Make sure to save your open Makinom project or schematics (in the Makinom editor) before importing any package, as importing a package will reset all unsaved changes.
Adding a Game Starter
To use Makinom in your running game, you need to initialize it before being able to access any functionality (e.g. a machine running a schematic).
Initializing Makinom in your scene is done using a Game Starter component, which selects the Makinom project asset that should be used.
Add game startes using the scene wizard or simply add the component via Unity’s component menu: Makinom > Scenes > Makinom Game Starter
You can have a game starter in each of your scenes to be able to hit play in the Unity editor right there, once Makinom is initialized, other game starters will not be used.
Learn more about game starters here.
Getting Started
You’re probably eager to try out Makinom – but where to start?
The best place to start is reading the basic documentations on schematics and machines to learn about the core concept of the work ow. You might also want to look into the Makinom editor to get an overview of the available features and where to nd the functionality you’re looking for, as well as the node editor (which you’ll use most of the time).
Beginner Tutorials
Once you’ve grasped the basics, or just skipped all that reading (learning by doing is also a good way to start), you can start with the easiest tutorial series and create a small Breakout game.
A bit more complex, but also for beginners is the Space Shooter tutorial.
Intermediate Tutorials
If you’re looking for something more challenging, try the Match 3 tutorial. It contains advanced mechanics with in-schematic machine starting and selected data.
The Survival Shooter tutorial features a di erent set of advanced mechanics, e.g. raycasting (for shooting hit detection), enemy movement and spawning.
Advanced Tutorials
For more complex tutorials, try the 2D Roguelike or 2D Platformer tutorials.
Updated on July 3, 2021
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System Flying Texts
Flying Texts
Follow World Position: Follow the world position the ying text is displayed on.
If disabled, the ying text will only be placed at the position, but stay at it’s current screen position.
The UI itself can still be moved in any case (e.g. via schematics to animate it).Flying texts allow you to display UI content for a short time, matching the position of a game object on screen.
The most common example for a ying text is displaying damage numbers or earned points at an enemy’s position when defeating it.
Flying texts are displayed using Show Flying Text nodes in schematics. Showing a ying text will create an empty game object in the scene at the position the text is displayed at (i.e. the used game object’s position).
Flying Text Settings
You can nd the default settings for ying texts in UI > UI Settings in the Flying Text Settings. Each individual ying text setup can optionally override the default settings for ying texts.
UI
Depending on the used UI module, the setup for ying texts can be di erent.
E.g. the Unity UI module uses a prefab to create a ying text.
Create Object Type
A ying text is displayed on screen for a position in the game world.
Generally, a ying text will always use a game object as the original object it’s placed on – i.e. the game object you use to display the ying text. However, the ying text can also create a new game object, which can be moved/changed independent from it’s original object.
Additionally, the Follow World Position setting de nes if the ying text follows the world position of it’s game object, e.g. camera changes will cause the ying text to reposition on screen based on the actual position in the game world. If disabled, the ying text will only be placed at the position when creating it, but stay at it’s current screen position.
There are 3 types of creations available.
None
Doesn’t create a game object and only uses it’s original position (or follows the original game object if it’s mounted).
This will be best for performance, since it doesn’t involve creating and destroying an extra game object.
Empty
Creates an empty game object at the ying text’s original position.
The game object can be moved, rotated, etc. using the schematic animating the ying text – it’s available as the Machine Object of the schematic.
Prefab
Creates an instance of a de ned prefab.
This allows you to create more complex ying texts, e.g. by using a prefab that’ll be impacted by physics.
When using the Unity UI module, you can add a Canvas to the prefab – the ying text’s UI will be displayed on the prefab’s canvas in this case. You can use this to create world space ying texts instead of screen space.
Visibility
A ying text’s on-screen visibility can optionally be checked via it’s viewport position of the camera.
I.e. if the ying text is not visible in the camera’s viewport, it’ll be hidden and not updated – this can improve performance.
Checking visibility is enabled by default.
Limit Display Range
Optionally limit the range at which new ying texts are created.
The range can be either to the player’s game object or the main camera.
Positions
Flying texts are placed based on a position of a game object, you can use positions to add random o sets to the game object’s position, mount the ying text to it (i.e. it’ll keep following the original game object), target a child object, etc.
You can add multiple positions, either using one randomly or using them in order. When using in order, you can automatically reset them after a de ned time.
E.g. using positions in order allows keeping ying texts out of each other’s way when they’re shown in quick succession.
Animation using Schematics
Flying texts can use schematics to animate them – the UI of the ying text is available as local selected data via the selected key ui.
In case the ying text creates a game object in the scene to position itself, the game object is available as Machine Object and the original object it’s based/placed on as Starting Object.
You can change the ying text’s color using a Change UI Color node (using the selcted data ui),
e.g. fading in/out the alpha value.
You can change the ying text’s position using a Change UI O set node (using the selcted data ui), the o set is from it’s game object’s on-screen position.
You can change the ying text’s scale using a Change UI Scale node (using the selcted data ui).
Tip: When Using Multiple Cameras
Flying texts are displayed on-screen based on where the camera sees the game object or world position they are placed at.
If you switch between di erent cameras, the main camera that was used when the level was loaded is still being used for positioning ying texts.
To switch the used camera, add an Is Makinom Camera component to each of the cameras. This component will set the game object’s camera as the main camera used by Makinom when the game object is enabled. Please note that this will only work if you enable/disable the cameras as needed.
Tutorials
You can nd tutorials for ying texts in the ORK Framework tutorials. ORK is an extension for Makinom 2.
Unity UI Setup
For an example setup for ying texts using the Unity UI module, see this ORK tutorial.
Animation Schematic
For an example setup for schematics animating a ying text, see this ORK tutorial. UI
Updated on December 17, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me
fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Formula Nodes
Formula Nodes
A list of all available nodes for formulas.
Formulas are used to calculate a value and uses individual nodes to manipulate the result. There are currently 63 formula nodes available (excluding nodes from extensions, e.g. ORK Framework).
Base
Layer Gate
Connects two layers.
Empty
This is an empty node.
This node being empty can be the result of a custom node script not being found (e.g. removed from the project).
Random
Randomly executes a next node out of a list of de ned nodes.
Comment
Leave a comment in your formula.
This node does nothing and is only for commentary purposes.
Chance
Which node will be executed next is decided by chance.
The chance is checked against a random number between two values (default 0 and 100, you can change this in the game settings).
The next node of the rst de ned value range, that includes the chance, will be executed. If no range contains the chance, ‘Failed’ will be executed.
Loop
Increases an int variable by one until it reaches a de ned maximum value.
Use this node to easily loop nodes for a number of times before continuing with the rest of the formula.
If the loop nished (i.e. the int variable being max count or larger), ‘Finished’ will be executed next, otherwise ‘Loop’.
Math Function
Uses a Mathf function on the current value of the formula.
Unity Console
Prints a text to the Unity console using ‘Debug.Log()’.
Begin Sub Calculation
Starts a new calculation as part of the formula (i.e. used as ‘left parenthesis’). Everything within a sub calculation will be calculated until it’s corresponding ‘End Sub Calculation’ node and added to the previous formula value using the de ned operator.
Any open sub calculation will be closed at the end of the formula’s calculation, before using the formula’s min/max value limits.
End Sub Calculation
Closes the last opened sub calculation (i.e. used as ‘right parenthesis’).
The sub calculation’s current value (result) will be used to change the previous formula value using it’s corresponding ‘Begin Sub Calculation’ node’s operator.
Float
Float Atan2
Uses the angle in radians whose Tan is y/x to change the current formula value or stores it into a oat variable.
Float Clamp
Clamps a oat value between a minimum and maximum and stores it into a oat variable.
Float Delta Angle
Calculates the shortest di erence between two angles and stores it into a oat variable.
Float Inverse Lerp
Calculates the Lerp parameter between two values and stores it into a oat variable.
Float Lerp
Interpolates between two values and stores it into a oat variable.
Float Move Towards
Moves a value current toward target and stores it into a oat variable.
Float Perlin Noise
Generates 2D perlin noise and stores it into a oat variable.
Float Ping Pong
PingPongs or loops (repeats) a value, so that it is never larger than length and never smaller than 0, and stores it into a oat variable.
Float Smooth Step
Interpolates between two values with smoothing at the limits and stores it into a oat variable.
Float To Angle
Changes a oat value into an angle (i.e. between 0 and 360) and stores it into a oat variable.
E.g. -90 will become 270, 480 will become 120.
Float is Power of 2
Checks if an int value is power of two.
If check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Position
Distance
The distance between user and target is used.
Check Distance
The distance between user and target is checked with the current value of the formula or a de ned value.
If the check is true, ‘Success’ will be executed next, otherwise ‘Failed’.
Angle
The angle between user and target (-180 – 180) is used.
Check Angle
The angle between user and target is checked with the current value of the formula or a de ned value.
If the check is true, ‘Success’ will be executed next, otherwise ‘Failed’.
Check Orientation
Checks the orientation from user to target (e.g. if the target is in front of the user). If the check is true, ‘Success’ will be executed next, otherwise ‘Failed’.
Check Height Di erences
Checks if the target is above or below the user.
If the check is valid, ‘Success’ will be executed next, otherwise ‘Failed’.
Selected Data
Clear Selected Data
Clears/removes selected data.
Either removes all data of a de ned data key, or removes all data.
Selected Data Count
Checks how many data is stored in a selected data list or uses the count to change the formula value.
When checking and if the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Select Selected Data
Uses the rst, last, a random or all content from another selected data as selected data.
E.g. select a random content from a list of data.
If something was stored, ‘Success’ will be executed, otherwise (i.e. nothing left to store) ‘Failed’.
Select Variable Handlers
Uses variable handlers to change selected data.
A variable handler stores all variables of an origin, e.g. the global variables or object variables of a game object.
Select Components
Uses components to change selected data.
Select Game Objects
Uses game objects to change selected data.
Value
Value
A single value is used.
Random Value
A random value between two values is used.
Minimum Value
The smaller value of two values is used.
Maximum Value
The bigger value of two values is used.
Check Value
A value (e.g. the current value of the formula will be checked with a de ned value. If the check is true, ‘Success’ will be executed next, otherwise ‘Failed’.
Limit Value
The current value of the formula will be limited.
Function Value
The return value of a called function is used.
Requires a function that takes a ‘FormulaCall’ as parameter, which gives you access to the user/target of the formula, current value and local variables/selected data, e.g.:
public oat YourFunction(FormulaCall call)
Field Value
The value of an int or oat eld/property is used.
Variable
Store Formula Value
Stores the current value of the formula into a oat variable.
Change Variables
Changes variables.
Check Variables
Checks if variables have certain values.
If the check is true, ‘Success’ will be executed, otherwise ‘Failed’.
Variable Fork
Checks if a single variable for certain values.
If a variable condition is valid, it’s next node will be executed. If no variable condition is valid, ‘Failed’ will be executed.
Clear Variables
Removes all variables and variable lists.
Store Function Result
Stores the return value of a function into a variable. Supports string, bool, int/ oat and Vector3 return values.
If a variable is changed, ‘Success’ will be executed, otherwise ‘Failed’.
Store Field
Stores the value of a eld or property into a variable. Supports string, bool, int/ oat and Vector2/Vector3 values.
If a variable is changed, ‘Success’ will be executed, otherwise ‘Failed’.
Variable Transfer
Transfers all variables and variable lists from one origin to another (local, global and object).
Variable Exists
Checks if a variable exists (i.e it has been set).
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Vector3
Vector3 Transform Value
Transforms a Vector3 value between local and world space of a game object and stores the result into a variable
Vector3 Angle
Uses the angle in degree between two Vector3 to change the current formula value or stores it into a oat variable.
Vector3 Magnitude
Uses the magnitude (length) or square magnitude (squared length) of a Vector3 to change the current formula value or stores it into a oat variable..
Vector3 Clamp
Store a Vector3 with it’s axes clamped between two values into a variable.
Vector3 Clamp Magnitude
Store a Vector3 with it’s magnitude clamped to a max length into a variable.
Vector3 Lerp
Store the linear or spherical interpolation between two Vector3 into a variable.
Vector3 Move Towards
Moves the Vector3 current in a straight line towards a target and stores it into a variable.
Vector3 Rotate Towards
Rotates the Vector3 current towards a target and stores it into a variable.
Vector3 Ortho Normalize
Make two or three Vector3 variables normalized and orthogonal to each other.
Vector3 Multiply
Multiplies a Vector3 with a oat and stores it into a variable.
Vector3 Divide
Divides a Vector3 by a oat and stores it into a variable.
Vector3 Rotate
Rotates a Vector3 and stores it into a variable.
Vector3 To Angle
Changes all axes of a Vector3 value into a angles (i.e. between 0 and 360) and stores it into a Vector3 variable.
E.g. -90 will become 270, 480 will become 120.
Updated on February 22, 2023
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Editor Game Section
Game Section
The Game section contains the settings related to the game (e.g. game states, languages) and that are used in your game world (e.g. formulas, camera positions, scene objects).
Game Settings
The Game Settings sub-section contains the basic game settings, e.g. the chance random range (default 0-100), raycast settings, initial sound/music channels and initial global variables.
The game settings also allow you to easily change asset sources for the complete project.
Unity Wrapper
The Unity Wrapper feature allows you to replace standard Unity functionality with custom implementations.
You can use it to implement 3rd party functionality for spawning and destroying game objects, scene loading and random number generation.
Performance Settings
The Performance Settings let you de ne data list pooling options. This can help improve the performance of your game.
Learn more in the performance optimization documentation.
Game States
The Game States sub-section de nes the game states that are available. Game states are mostly used as conditions for starting machines, displaying HUDs and in schematics.
You can learn more in the game states documentation.
Languages
The Languages sub-section de nes the languages that are available. You can also export and import languages here.
Learn more in the languages documentation.
Formula Types
The Formula Types sub-section de nes the formula types that are available. Formula types are used to organize and lter formulas in the Makinom editor.
Formulas
The Formulas sub-section de nes the formulas that are available. Formulas are de ned in a node-based editor and are used to calculate a oat value.
Formulas are useful if you often need to calculate a value, e.g. using object variables containing attributes of player and enemies to calculate the attack damage.
Formulas, like schematics, are created using the node editor.
Camera Positions
The Camera Positions sub-section de nes the camera positions that are available. Camera positions are used in schematics and Camera Event components to place or mvoe the camera to de ned positions using a target game object.
Camera positions are optional, you can also place and move the camera as you’d move any other game object.
Music
The Music sub-section de nes the music that is available. Music is used by schematics and Music Player components to change the background music of your game.
Learn more in the audio and music documentation.
Scene Object Types
The Scene Object Types sub-section de nes the scene object types that are available. Scene object types are used to organize and lter Scene Objects and add additional type information to them.
Learn more in the scene objects documentation.
Scene Objects
The Scene Objects sub-section de nes the scene objects that are available. Scene objects are used to add information to game objects using a Scene Object component.
Scene objects de ne the name and description of game objects. They can also add portraits and object variables to game objects.
This information can be used by HUDs (e.g. displaying the name of an interaction) and schematics (e.g. name and portraits of a dialogue’s speaker).
Learn more in the scene objects documentation. Editor
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Getting Started Game Starters
Game Starters
Game starters are crucial to starting Makinom and your game – learn more about them and where they’re used.
Game starters are Unity components that are added to game objects. They’re used to initialize Makinom and load a selected project’s data.
A game object with a game starter is represented in the Unity scene view by this gizmo icon:
You can’t use machines or any other Makinom mechanics without rst initializing Makinom with a game starter.
Using Game Starters
The game starter should be added to the rst scene of your game, or at least the rst scene that uses Makinom mechanics (e.g. machines).
The most important setting of the game starter is the Project Asset:
Project Asset
Select the Makinom project asset le that you want to use here.
The default project asset le can be found at Assets/Gaming Is Love/_Data/Project.asset.
The Start Schematic can also be used to do additional things after Makinom is initialized.
Start Schematic Asset
Select a schematic asset le you want to start after initializing Makinom.
This is optional and can be used to e.g. do further initializing through schematics or display a start menu.
Adding a Game Starter
When using the scene wizard to add a game starter (Add Game Starter), you’ll rst be able to select the Makinom project asset you want to use. The default project asset le will be automatically selected (found at Assets/Gaming Is Love/_Data/Project.asset). Clicking on Add Game Starter again will create a new game object and add the game starter component.
Otherwise, you can add a game starter component to a game object through the components menu (Makinom > Scenes > Makinom Game Starter).
Quick Game Testing
Since you’ll often just want to test a scene you’re currently building, you’ll also need to add a game starter to that scene as well. Otherwise, you’d need to go through your start scene where you’ve added the game starter.
Having multiple game starters in your game isn’t a problem – the rst game starter that’s used will initialize Makinom and load the project. Once Makinom is initialized, other game starters wont be started.
In case you’re using game states to only display HUDs or run machines in a running game, you can enable Start Game in the game starter’s inspector to start a new game when initializing Makinom – otherwise this’ll only happen when using a New Game node in a schematic.
You can also execute a schematic when Makinom is initialized, select it in the Start Schematic Asset setting of the game starter.
Updated on July 3, 2021
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Game States
Game States
Learn more about game states and what you can use them for.
Game states are an easy way to keep track of what’s currently happening in your game. A game state is either Active or Inactive, the game can have multiple active states at the same time.
Game states are mostly used as conditions for starting machines or displaying HUDs, and can be checked in schematics to decide the next nodes that will be executed.
Game states are set up in Game > Game States.
Changing Game States
Game states can be changed by schematics (using a Change Game State node) or automatically through certain events or other game states being activated or inactivated.
Auto Activate/Inactivate
A game state can be automatically activated or inactivated by the following events:
Start Game
When the game is started (using a Start Game node).
Stop Game
When the game is stopped (using a Stop Game node).
Pause Game
When the game is paused (e.g. using a Pause Game node).
Unpause Game
When the game is unpaused (e.g. using a Pause Game node).
Start Scene Change
When starting a scene change (before fading out).
End Scene Change
When ending a scene change (after fading in).
Start Blocking Machine
When starting a Blocking execution type machine.
End Blocking Machine
When ending a Blocking execution type machine.
Block Player Control
When the player control is blocked (e.g. using a Block Player Control node).
Unblock Player Control
When the player control is unblocked (e.g. using a Block Player Control node).
Block Camera Control
When the camera control is blocked (e.g. using a Block Camera Control node).
Unblock Camera Control
When the camera control is unblocked (e.g. using a Block Camera Control node).
The events can be added in the game state’s settings in the Makinom editor.
You can also create custom events by deriving your class from the BaseGameStateChangeType class. Check the classes for the available events for examples.
Examples
The game state Game Running is auto activated by the event Start Game and auto inactivated by the event Stop Game.
While the player is playing the game (e.g. started through a main menu), the Game Running state will be active and can be used to display HUDs.
The game state In Control is auto activated by the event Unblock Player Control and auto inactivated by the event Block Player Control.
The machine handling player control (e.g. a tick machine) and all interaction machines will only start if the In Control state is active. The game can only be controlled while the player controls aren’t blocked.
Changing by other Game States
You can add game states that will be changed when a game state is activated and inactivated in the game state’s settings in the Makinom editor.
Game State Conditions
The current state of game states can be checked by Game State Conditions.
Checking Conditions
Game state conditions can check multiple conditions. Either all or only one of the check conditions must be valid for the game state condition to be valid.
A single condition can check:
Game State
Checks if a single game state is active or inactive.
Conditions
Checks multiple game states, either all or only one of the game state checks must be valid. This can be used to create complex game state conditions.
Template
Checks a game state condition template.
Schematics
Schematics can check game state conditions using a Check Game State node. The next node that will be executed is determined by the conditions being valid or not.
Machines
Machine components and global machines can use game state conditions to determine if the machine can start.
You can also check the start conditions of a machine in it’s running schematic using a Check Start Conditions node.
HUDs
HUDs can use game state conditions to determine if they’ll be displayed.
Example
A game state condition has 2 conditions, one of them must be valid:
Condition 1 (Game State)
Checks if the single game state A is active.
Condition 2 (Conditions)
Checks if the game states B and C are active (i.e. all checks must be valid).
Game states A and C are inactive, game state B is active – the whole condition is invalid. Game state A is active – the whole condition is valid, game states B and C don’t matter. Game state A is inactive, B and C are active – the whole condition is valid.
Templates
Usually, you’ll keep checking the same game state conditions very often in a game. To prevent setting up a condition each time you need it, you can create a Game State Condition Template, that can be used by game state conditions.
You can create templates in Templates > Game State Condition Templates.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Global Machine
Global Machine
Learn more about global machines and what you can use them for.
Unlike machine components, global machines aren’t added to game objects or animator controller states. They’re added in the Makinom editor (Base/Control > Global Machines) and can be started everywhere and anytime.
Using Global Machines
A global machine isn’t bound to a game object and is available globally, i.e. they can be started in all scenes and at all times. Like machine components, global machines will play a schematic.
Starting a Global Machine
A global machine can be started by schematics (Start Global Machine node) or HUD click actions. Starting a global machine via schematic will allow selecting the Machine Object and Starting Object.
Additionally, global machines can be started automatically. This is handled by the global machine’s Execution Settings.
Call
This global machine type will only start when called (e.g. by a schematic). All other global machine types can also be started upon call.
E.g. a schematic will check for game over conditions and handle ending the game. The
schematic needs to be started by various other schematics.
Setting this mechanic up as a call global machine allows starting it whenever needed,
without adding it to a speci c game object.
Auto
The auto global machine will start automatically based on time and de ned conditions. You can de ne a timeout between condition checks to e.g. only run the machine once per minute (60 second timeout).
Starting the machine can depend upon Game State Conditions and Variable Conditions.
E.g. a schematic handles a custom time system, increasing minutes, hours and days of in-
game time (using variables).
Setting this mechanic up as an auto global machine with a timeout of 5 will increase the
in-game time by 1 minute every 5 seconds.
Additionally, using the conditions, the time progression can be paused when needed, e.g. during cut-scenes or scene changes.
Key
The key global machine will start when a de ned input key is used. When the input key is used (e.g. Escape pressed down), the global machine will start if the conditions are valid.
Starting the machine can depend upon Game State Conditions and Variable Conditions.
E.g. a schematic handles a menu (Show Dialogue node) that should be displayed when the player presses the menu input key (e.g. using the Escape key).
Setting this mechanic up as a key global machine allows calling the menu without adding it to a speci c game object. The menu is available whenever needed.
Additionally, using the conditions, the menu call can be blocked when needed, e.g. during cut-scenes or scene changes.
Scene
The scene global machine will start when changing the scene. The machine can optionally be started in the old scene (i.e. before changing scenes) or in the new scene (i.e. after changing scenes), additionally the machine can run before or after fading the screen.
The Scene Change Type de nes which scene changes can start the global machine, e.g. starting for All scene changes, only from Scene Changers, when loading the game or for Custom scene change types (de ned by scene changers and Load Scene nodes in schematics).
Starting the machine can depend upon Game State Conditions and Variable Conditions.
E.g. a schematic saves the game to the auto save slot. The game should be saved
automatically whenever the player enters a new scene.
Setting this mechanic up as a scene global machine (running in the new scene) will save
the game whenever a new scene has been loaded.
Additionally, using the conditions, the auto save can be prevented when needed.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System HUDs
HUDs
HUDs are used to display information of the player and other things or add interactable functionality.
HUDs are set up in UI > HUDs.
De ning the actual position, size, style and content of a HUD depends on the used UI module,
e.g. using the Unity UI module uses a prefab of the game object and component setup you created. Please refer the used UI module’s documentation for details.
HUD Types
There are HUD types available for di erent purposes. Depending on the used UI module you’ll be able to mix functionality of di erent HUD types, e.g. the Unity UI module can mix individual components together as needed.
You can also create custom HUD types by deriving your class from the BaseHUDSetting class. Check out the included HUDs for examples and how to use UI system dependent setup.
Control
Control HUDs are intended for creating virtual controls like on-screen buttons and joysticks.
Information
Information HUDs are used to display information. They can either be displayed on their own or based on a user (e.g. a game object, the player, etc.) and display information based on that.
When the HUD has a user, it can also be displayed based on the user’s game object position on screen.
Interaction
Interaction HUDs are used to display information of available interactions, either from within the player’s Interaction Controller or below the mouse cursor.
The HUD can optionally be displayed at the position of the interaction or player (i.e. on-screen position of their game objects). Information displayed within the HUD depends on the displayed interaction, e.g. using a Scene Object component on an interaction allows de ning content information like name or description and use that in the HUD.
Tooltip
Tooltip HUDs display information of the current tooltip content. The tooltip content is whatever is currently below the mouse cursor (or a locked content from some UI selection), e.g. a game object with content information (like Scene Object component) or a part of a UI that has a tooltip (e.g. a choice button).
Display Conditions
Displaying a HUD can depend on certain conditions.
You can de ne Game State and Variable conditions that have to be valid to display the HUD.
Some HUD types can also have additional settings, e.g. interaction HUDs can be limited to certain interaction types.
Showing HUDs
If a HUD is displayed automatically is de ned by it’s Auto Display setting. Additionally, you can toggle displaying the HUD on/o using the Toggle Key settings.
When not displayed automatically, you can call a HUD using a Call HUD node in a schematic.
You can also use an Add HUD (to Game Object) component to add a HUD instance for the game object it’s attached to. E.g. use it to add health bars or other UI for enemies, automatically using them as the HUD’s user (e.g. displaying it at their position, using their variables for content information, etc.).
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System HUDs: Click Actions
HUDs: Click Actions
Learn more about HUD click actions.
HUD click actions are used to execute something when clicking on a part of a HUD.
The click actions can use their content provider’s user/content in their action. You can learn more about content providers in this documentation.
Click Actions
Each click action de nes how it’ll be started.
Click Count
De nes how many clicks are needed to start the action.
E.g. 1 for a single click or 2 for a double click.
Left/Middle/Right Click
De nes which mouse button is used.
Release After
Optionally require the click to be held for a de ned time.
Consume Click
De nes if the action consumes the click.
If the click is consumed, click actions added after the consuming action will not use the click (if the action was used).
Disabling this allows to use multiple actions with the same click.
Click Clip
Optionally play an audio clip when using the click action.
The following click actions are available (other Makinom extensions can add their own click actions, e.g. ORK Framework).
Global Machine
A global machine is started, using the content provider’s user/content as machine object and the player as starting object.
Schematic
A schematic is started, using the content provider’s user/content as machine object and the player as starting object.
Tagged Machine
A tagged machine is started, either on the content provider’s user/content or all tagged machines in the scene.
Toggle HUDs
Toggles other HUDs on/o .
UI Modules
The actual use of HUD click actions depends on the used UI module.
Unity UI
The Unity UI module uses the HUD Click components to add HUD click actions.
The component also requires some graphic element that catches UI raycasts, e.g. an Image component (even when not displaying anything in it).
Updated on September 17, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me
fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System HUDs: Conditions
HUDs: Conditions
Learn more about HUD conditions.
HUD conditions are used to show or hide HUD elements.
The conditions use their content provider’s user/content for their checks. You can learn more about content providers in this documentation.
Available Conditions
The following conditions are available (other Makinom extensions can add their own conditions, e.g. ORK Framework).
Game State
Check if game states are active or inactive.
This condition doesn’t use the content provider’s user/content for it’s check.
General Condition Template
Check a general condition template with a de ned user and target. The conditions can depend on the content provider’s user/content.
HUD User
Check if the content provider’s user/content being a de ned content/thing. Uses Tooltip type HUD checks, but doesn’t require a tooltip HUD.
Variable
Check variable conditions.
Using Local variable origin will check variables of the content provider’s user/content. Object variable origin can use the user/content’s object variables.
UI Modules
The actual use of HUD conditions depends on the used UI module.
Unity UI
The Unity UI module uses the HUD Condition components to add HUD conditions.
The component will enable/disable the game object it’s attached to based on the conditions.
Updated on September 17, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System HUDs: Content Providers
HUDs: Content Providers
Learn more about HUD content providers.
Content providers are used to de ne the content that’s displayed by HUD elements.
The root HUD itself is a content provider and will get it’s content (also refered to as user) from the HUD it’s used to display (see this documentation on HUDs).
The actual use of content providers depends on the used UI module.
Unity UI
The Unity UI module uses components to add content providers.
Content components have a Content Provider eld available to de ne which content provider they get their displayed content from.
The following content providers are available (other Makinom extensions can add their own content providers, e.g. ORK Framework).
HUD
The HUD component is the root of all HUDs and is a content provider. It’ll get it’s content from the HUD that’s displaying it.
HUD Content Provider
The HUD Content Provider component is an empty content provider.
It’s mainly used on UI prefabs that are created by other HUD content components, e.g. listing things by spawning prefabs for each listed content. The content of the HUD Content Provider component that’s found on a spawned prefab will be set to the used content.
HUD Content Provider (GameObject)
The HUD Content Provider (GameObject) component uses a de ned game object as it’s content.
The game object is de ned by a game object selection, e.g. allowing to use the Player or something stored in Selected Data as content.
Updated on September 17, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Input Keys
Input Keys
Learn more about Makinom’s input system.
Input keys build a control layer between Makinom and various input sources (e.g. Unity’s input manager or 3rd party solutions). This allows inputs to be set via Control HUDs (for virtual on screen controls, e.g. on mobile platforms), schematics (Set Input Key node) or via scripting.
You can create new input keys in Base/Control > Input Keys.
Input Origin
The input origin de nes where an input key’s input is coming from. There are several input origins available out of the box and you can use the Custom input origin to quickly connect 3rd party input systems via re ection.
You can also create custom input origins by deriving your class from the BaseInputIDKeySetting. Check out the included input origins for examples.
Input Origin: Select where the input of the key will come from:
Acceleration
Uses a selected axis of the last linear acceleration of a device.
This is usually only available on mobile devices that have an acceleration sensor.
Custom
Uses re ection to call static functions of a class.
You can add parameters to the function calls, e.g. a string parameter to pass on an identi er/name for the input you want to use.
Button Function
The function for button input has to return a bool value.
Axis Function
The function for getting the input’s axis value has to return a oat value.
Gyroscope
Uses a selected axis of gyroscope data of a device.
This is usually only available on mobile devices that have an gyroscope sensor.
Input Key
Uses other input keys as input.
This can be used to bundle multiple sources into a single input key, e.g. when having multiple horizontal and vertical inputs (from keyboard, controllers, etc.).
Another use is key combinations, e.g. allowing Alt + 1 as an input.
Key Code
Uses the key mapped to a selected key code.
This is a quick and easy way to set up inputs without any additional setup in the Unity input manager or other input sources.
Key Combo
Uses an input key combo sequence.
This allows getting an input after a de ned sequence of input keys was used, e.g. A > A or Up > Down > Up > Down.
The individual parts of the sequence can de ne a timeout until the sequence is reset and input keys to ignore (i.e. not break the sequence).
Mouse
Uses a mouse button and mouse position change as axis.
None
This doesn’t use a direct input.
Use this input origin for input keys that should only receive input from HUDs, schematics or via code.
Touch
Uses a touch input and touch position change as axis.
This is usually only available on devices with touch screens (e.g. mobile phones or tablets).
Unity Input Manager
Uses a key de ned in the Unity input manager.
E.g. the scroll wheel of a mouse is usually set up via the input manager.
Input IDs
Input IDs allow having multiple input origins for an input key. They’re used to create di erent control styles/layouts or allow local multiplayer controls.
The default (global) input ID is 0 when starting a game. Machines can either use the default input ID or override it, i.e. this can be used to have machines with the same schematic react to di erent input.
The global input ID can also be changed in-game, e.g. for switching control styles.
The minimum input ID is 0, an input ID of -1 can be used to check for any inputs of an input key (ignoring input ID).
Example
The Accept and Cancel input keys have 2 input origins each.
Accept uses joystick button 1 for input ID 0 and joystick button 2 for input ID 1. Cancel uses joystick button 2 for input ID 0 and joystick button 1 for input ID 1. Switching the global input ID between 0 and 1 allows switching the Accept and Cancel
input key’s buttons.
Share This Article :
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Interaction Machine
Interaction Machine
Learn more about interaction machines and what you can use them for.
Interaction machines are Unity components that are added to game objects. They’re mostly used for game mechanics involving player interaction, like showing a dialogue when talking to a NPC.
An interaction machine component can be added through the components menu (Makinom > Machines > Interaction Machine) or the scene wizard (Add Machine >
Interaction Machine). A game object with an interaction machine is represented in the Unity scene view by this gizmo icon:
You can learn more about machine components in general and their basic settings here.
Start Types
An interaction machine is started by player interactions, e.g. using the Interact Key or mouse/touch.
Interact
Started upon player interaction. The player can interact with game objects by pressing
the Interact Key (de ned in the Makinom editor: Base/Control > Game Controls > Interaction Settings).
A game object is available for interaction when it’s selected or within the player’s Interaction Controller trigger. You can learn more about interactions in this how-to.
Additional Start Conditions
The Interact start type can optionally be limited by the distance between the player and the machine’s game object. This can be used to only start the machine when within a de nd range.
The default maximum interaction distance is de ned in the Makinom editor (Base/Control > Game Controls > Interaction Settings) and can be overridden by each interaction machine individually. Setting the maximum distance to -1 will disable distance checks (default setting).
Example
This start type can be used to display dialogues with NPCs. Use a Show Dialogue node to display a dialogue or choice dialogue.
Key Press
Started upon the player pressing a de ned input key. This can optionally be limit to only happen while the player is within the the trigger of the machine’s game object or while colliding with the machine’s game object.
Additional Start Conditions
The Key Press start type can optionally be limited by the distance between the player and the machine’s game object. This can be used to only start the machine when within a de nd range.
The default maximum interaction distance is de ned in the Makinom editor (Base/Control > Game Controls > Interaction Settings) and can be overridden by each interaction machine individually. Setting the maximum distance to -1 will disable distance checks (default setting).
Example
This start type can be used to show game menus. Use a Show Dialogue node to create menus (Choice dialogue type).
Mouse Down
Started when a mouse button is pressed down while the curser is over the machine’s game object. It’s implemented in the component’s OnMouseDown function.
Additional Start Conditions
The Mouse Down start type can optionally be limited by the distance between the player and the machine’s game object. This can be used to only start the machine when within a de nd range.
The default maximum mouse click distance is de ned in the Makinom editor (Base/Control > Game Controls > Interaction Settings) and can be overridden by each interaction machine individually. Setting the maximum distance to -1 will disable distance checks (the default distance is 3).
Example
This start type can be used to mark a clicked game object. Use a Spawn Prefab node to spawn a cursor prefab on the game object or a Change Color node to change the game object’s color.
Mouse Drag
Started when the mouse is dragged, i.e. while the button is held down after clicking on the machine’s game object. It’s implemented in the component’s OnMouseDrag function.
Additional Start Conditions
The Mouse Drag start type can optionally be limited by the distance between the player and the machine’s game object. This can be used to only start the machine when within a de nd range.
The default maximum mouse click distance is de ned in the Makinom editor (Base/Control > Game Controls > Interaction Settings) and can be overridden by each interaction machine individually. Setting the maximum distance to -1 will disable distance checks (the default distance is 3).
Example
This start type can be used to drag game objects through the scene by mouse. Use one of the Movement nodes (e.g. a Change Position node) to change the position of the game object – additionally, you can use a Raycast node to store the position of the mouse cursor in the scene into a Vector3 variable and use that to move the game object.
Mouse Up
Started when the mouse is released after clicking on the machine’s game object. It’s implemented in the component’s OnMouseUp function.
Additional Start Conditions
The Mouse Up start type can optionally be limited by the distance between the player and the machine’s game object. This can be used to only start the machine when within a de nd range.
The default maximum mouse click distance is de ned in the Makinom editor (Base/Control > Game Controls > Interaction Settings) and can be overridden by each interaction machine individually. Setting the maximum distance to -1 will disable distance checks (the default distance is 3).
Example
This start type can be used to mark a clicked game object. Use a Spawn Prefab node to spawn a cursor prefab on the game object or a Change Color node to change the game object’s color.
Mouse Up As Button
Started when the mouse is released while the cursor is over the machine’s game object after clicking on it. It’s implemented in the component’s OnMouseUpAsButton function.
Additional Start Conditions
The Mouse Up As Button start type can optionally be limited by the distance between the player and the machine’s game object. This can be used to only start the machine when within a
de nd range.
The default maximum mouse click distance is de ned in the Makinom editor (Base/Control > Game Controls > Interaction Settings) and can be overridden by each interaction machine individually. Setting the maximum distance to -1 will disable distance checks (the default distance is 3).
Example
This start type can be used to mark a clicked game object. Use a Spawn Prefab node to spawn a cursor prefab on the game object or a Change Color node to change the game object’s color.
Mouse Enter
Started when the mouse cursor enters the machine’s game object. It’s implemented in the component’s OnMouseEnter function.
Additional Start Conditions
The Mouse Enter start type can optionally be limited by the distance between the player and the machine’s game object. This can be used to only start the machine when within a de nd range.
The default maximum mouse click distance is de ned in the Makinom editor (Base/Control > Game Controls > Interaction Settings) and can be overridden by each interaction machine individually. Setting the maximum distance to -1 will disable distance checks (the default distance is 3).
Example
This start type can be used to mark a game object by moving the cursor over it. Use a Spawn Prefab node to spawn a cursor prefab on the game object or a Change Color node to change the game object’s color.
Mouse Over
Started while the mouse cursor is above the machine’s game object. It’s implemented in the component’s OnMouseOver function.
Additional Start Conditions
The Mouse Over start type can optionally be limited by the distance between the player and the machine’s game object. This can be used to only start the machine when within a de nd range.
The default maximum mouse click distance is de ned in the Makinom editor (Base/Control > Game Controls > Interaction Settings) and can be overridden by each interaction machine individually. Setting the maximum distance to -1 will disable distance checks (the default distance is 3).
Example
This start type can be used to rotate a game object while the cursor is over it. Use one of the Rotation nodes (e.g. a Rotate node) to rotate the game object.
Mouse Exit
Started when the mouse cursor leaves the machine’s game object. It’s implemented in the component’s OnMouseExit function.
Additional Start Conditions
The Mouse Exit start type can optionally be limited by the distance between the player and the machine’s game object. This can be used to only start the machine when within a de nd range.
The default maximum mouse click distance is de ned in the Makinom editor (Base/Control > Game Controls > Interaction Settings) and can be overridden by each interaction machine individually. Setting the maximum distance to -1 will disable distance checks (the default distance is 3).
Example
This start type can be used to remove the marking of a game object. Use a Destroy Object node to destroy a cursor game object or a Change Color node to change the game object’s color back.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Getting Started Introduction
Introduction
A short introduction to Makinom’s features.
Makinom is an editor extesion for the Unity. It’s a powerful and exible general-purpose game development toolkit, allowing you to create game controls, game mechanics or interactions with your game world without writing a single line of code.
You can create all kinds of 2D or 3D game genres, like roguelikes, platformers, shooters, action-adventures, 1st- or 3rd-person, and many more. Check out the tutorials for some examples.
Unity Compatibility
Makinom currently supports any Unity version since Unity 2019. It’s recommended to stick to Unity’s LTS (long-term support) versions, e.g. Unity 2019.4.
When a new Unity version is released, it might contain changes that break compatibility with the current Makinom version. This’ll usually be xed with a new version within a few weeks after Unity’s release. There’s no o cial support for Unity’s alpha or beta versions.
Some extensions to Makinom (e.g. UI modules or plugins) might require certain packages to be installed in the project, e.g. using the Unity UI module requires using Unity UI and TextMesh Pro packages.
Supported Platforms
Makinom o cially supports the following build targets:
PC Standalone Mac Standalone Android
iOs
Since Makinom’s features are implemented using basic/cross-platform APIs, it’ll most likely also work on other platforms (e.g. Nintendo Switch and other consoles), but they’re untested.
Features
Before getting into the details in the following documents, let’s get a quick overview over some of Makinom’s core features.
Schematics
Schematics are reusable, node-based blueprints of what you want to do. They work similar to
ow charts, each node performs a task and decides the next node that’ll be executed. There
are over 400 nodes available, ranging from simple things like playing an audio clip, spawning a prefab or increasing a counter to complex operations like moving/rotating over time or fading to a new camera position.
Schematics are used to create player/camera controls, game mechanics, dialogues and other interactions, cut-scenes, AI and handle animations, movement and many other things.
Learn more in the schematics documentation.
Machines
Machine components are used to play your schematics (but schematics can also play other schematics). There’s a machine for every use case, e.g. Tick Machines handle update-based functionality like player/camera controls, Trigger Machines can start when an object enters an area or Collision Machines when a bullet hits a target.
Tagged Machines are used to create a uniform setup for your game mechanics, e.g. starting whatever happens when something is killed or destroyed via the same tag (e.g. ‘kill’), for items and other pickups this can trigger collection, while on enemies it’ll play their death animation and drop loot or increase the score.
Often used machines can be set up as templates for easy reusability.
Learn more in the machines documentation.
Languages
Makinom supports setting up content in multiple languages, as well as easy export and import of language data for translations, including notes to the translators.
Learn more in the languages documentation.
Input Keys
Input keys are an extensible input system with support for local multiplayer and control styles via the Input ID system.
Learn more in the input keys documentation.
Variables
Variables are used to store information in a running game. This information could be anything – like the player’s health, ammunition or marking a solved quest. You wont be able to create a game without using variables, they’re needed in basically all game mechanics you’ll
create. Variables can be available globally (i.e. everywhere), bound to a game object or within a local execution (e.g. in a running schematic).
Learn more in the variables documentation.
Game States
Game states are simple states that are either active or not. You can set up your own game states to manage e.g. if a HUD should be displayed or a machine be able to execute.
They can either be changed automatically (e.g. upon pausing/unpausing the game or blocking/unblocking player controls) or via schematics.
Learn more in the game states documentation.
Modular UI System
Build HUDs, dialogues, menus and ying texts (e.g. damage numbers). HUDs can also be used for virtual controls.
The UI system is modular and completely separated from the rest, allowing you to switch it out if needed.
Learn more in the UI system documentation.
Save Games
Makinom includes a save game system to save the current state of your game, including variables, game states and the player’s position (and scene).
Learn more in the save games documentation.
Formulas
Create node-based formulas for often used or complex calculations, e.g. damage calculations.
Audio/Music
Makinom includes a music system for fading between di erent tracks, as well as multiple music channels.
You can also use audio channels to play sound e ects and control their volume independently.
Learn more in the audio and music documentation.
Game Object Pooling
Use pooling to reduce performance impact from spawning and destroying often used game objects, e.g. bullets red by a gun.
Updated on July 3, 2021
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Languages
Languages
Learn more about how Makinom 2 manages multiple languages and exporting/importing content for translations.
Localization is a crucial and often complex part of game development – that’s why Makinom 2 tries to make it as easy as possible for you!
You can create new languages in Game > Languages in the Makinom editor. Languages can be added whenever you need them, i.e. you can start development with just a single language and add further languages once you start translating your content.
Language Content De nitions
Wherever content is de ned that might need to be available in multiple languages, it’ll be handled like this:
You can de ne a default content and additional content for a de ned language. The default content is used for all languages as long as there’s no additional content added for a language. A running game will use the language content if the current language is matching it, otherwise it’ll fall back to the default content.
Beside text, the content often also involves sprites or textures. If you add a language content, you also need to select that content again, as once you’re using a separate content for a language, it’ll not fall back to the default content even if e.g. the language content doesn’t
de ne a sprite, but the default content has one de ned.
When creating your game’s content, it’s best to only de ne the default content and handle the language speci c content via the language export/import functionality. When importing language data, it’ll create new language content for the imported languages and also copy over any sprite/texture content from the default content. In case you already de ned a language content, the import will only replace the text of the language content, but keep the de ned sprite/texture intact and no longer copies it over from the default content.
Translation Export
Each content de nition has options to include it in language export/import. Content will be exported by default, in case something doesn’t need to be translated, disable Use Language Export in the content’s settings.
You can also include a note for the translator, e.g. if you need to provide some context or clari cations.
Export/Import
You can export and import all your language content texts in Game > Languages. The export/import system is modular and can support multiple formats.
Formats
You can create custom export formats by deriving your class from the BaseLanguageExportFormat (namespace GamingIsLove.Makinom.Editor).
The format options will be used for both exports and imports, i.e. when importing, make sure that the options match the importing le.
The exported data can optionally include information about where the text is coming from (Include Information setting) and the translation notes de ned in the language contents (Include Translation Note setting). Both settings are enabled by default. If your import le no longer contains the information or translation notes, make sure to disable those settings before loading the le.
CSV (UTF-8)
The default implementation exports/imports in CSV format (UTF-8 encoded) and lets you de ne the separator (defaults to ;) and optional text enclosers (defaults to “).
You can further process the le with any table calculation program like Excel from Microsoft. When using Excel, make sure to import the CSV-data instead of opening the le directly, as it’ll otherwise not use the UTF-8 enconding and can lead to reading certain special characters wrong.
After processing and converting the le back to a CSV le (UTF-8 encoded), make sure to still include the Export ID and Index columns.
Exporting
Exporting language content is separated into four di erent parts. Each part will create a separate le in the selected format.
Each language content that’s exported will receive an export ID, i.e. it’ll also cause changes and requires saving the changes. Depending on the exported part, some things will be saved automatically, but you’ll need to save in the Makinom editor in any case to keep track of the last export ID.
To create a fresh export and assign new export IDs, enable Reset Export IDs in the export settings. Please note that this’ll make any previous export invalid, as export IDs might no longer match. Without export IDs, the content might be assigned to the wrong settings (or not at all) when importing again.
Export Settings
The settings export contains all language content that’s de ned in the settings you made in the Makinom editor (excluding schematics).
You need to save the settings in the Makinom editor to keep the export IDs.
Export Scenes
The scenes export contains all language content that’s de ned on game objects (via components) in your scenes. This only includes scenes that are added to Unity’s build settings.
Exporting scene data will close the current scene and open all scenes one by one, before returning to the current scene. Make sure to save any changes you made in the current scene, as they’ll otherwise be lost.
The export IDs will be saved automatically with each scene, but you still need to save in the Makinom editor to keep track of the last export ID.
Export Prefabs
The prefabs export contains all language content that’s de ned on prefabs (via components) in your project.
The prefabs will be saved in case they contain language content that’ll be exported, as they need to keep their export IDs, but you still need to save in the Makinom editor to keep track of the last export ID.
Export Schematics
The schematics export contains all language content that’s de ned in schematics in your project. You can optionally limit the schematics to only include a de ned folder (and subfolders).
The schematics will be saved in case they contain language content that’ll be exported, as they need to keep their export IDs, but you still need to save in the Makinom editor to keep track of the last export ID.
Importing
To import a le, you rst need to select a le and load the le’s content via the Load Exported File button.
Once the le is loaded successfully, you’ll see more information about the le’s content, including the number of separate language contents it includes. You can also select which language will be imported.
Like exporting, importing is also separated into the four di erent parts as explained before. After loading the le, you’ll have the 4 import buttons available – make sure to use the correct button for the le you’re importing, as they’ll most likely share export IDs (each of the four export les will start with export IDs at 0).
Editor Language
You can also change the language of the editor’s help texts by exporting the default texts (as a CSV), translating it and setting it as the editor’s help text le.
To do this, navigate to Editor > Editor Settings and click on the Export Default Help button. This will export all help texts (default english texts) as a CSV le (UTF-8 formatted).
The translated CSV has to keep the same structure, i.e.:
rst line contains headers
rst column contains the identi cation of the texts
2nd column contains the names of the settings 3rd column contains the help texts of the settings
Please note that the help texts are found based on the identi cation, which relies on the class/ eld the setting is in. When something changes in an update (e.g. a class or eld being renamed), the translated help texts can no longer be found and you’ll have to retranslate the default texts.
You can use Google docs to quickly translate CSV les.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Machine Components Overview
Machine Components Overview
Machines are what drives your game – learn the basics about those components!
A machine is a Unity component that plays a Schematic – in short, a schematic is a blueprint for what you want to do, and a machine makes it happen. You can learn more about schematics in this how-to.
There are di erent machine components available for di erent use cases. Each machine component has it’s own documentation with more details, so let’s just get a brief overview.
Animation Machines
Started by animation callback functions, e.g. when the internal IK of an animator is updated.
You can learn more about animation machines here.
Animation State Machines
Started by Mecanim animator controller state changes (StateMachineBehaviour), e.g. when entering a state or state machine. This machine component is only available for animator
controller states and not for game objects.
You can learn more about animation state machines here.
Application Machines
Auto Machines
Started by creation or destruction of game objects, e.g. when a game object is instantiated, enabled or disabled.
You can learn more about auto machines here.
Collision Machines
Started by game objects colliding with the machine, e.g. when a game object starts or stops colliding with the machine.
You can learn more about collision machines here.
Interaction Machines
Started by player interaction, e.g. when clicking on the machine by mouse/touch or the pressing the Interact Key (while the machine is in the player’s Interaction Controller or the selected object).
You can learn more about interaction machines here.
Render Machines
Started by renderer and camera callback functions, e.g. when the machine becomes visible or invisible.
You can learn more about render machines here.
Tagged Machines
Started by schematics via tags, e.g. a schematic can start all machine tagged ‘explode’ in the scene.
You can learn more about tagged machines here.
Template Machines
Adds a machine component based on a template setting. You can learn more about template machines here.
Tick Machines
Started by update functions, e.g. every frame (Update) or xed framerate frame (FixedUpdate, used for physics handling).
You can learn more about tick machines here.
Trigger Machines
Started by game objects in the machine’s trigger, e.g. when a game object enters or leaves the trigger.
You can learn more about trigger machines here.
Beside machine components, there are Global Machines that can be used everywhere and anytime. You can learn more about global machines here.
Machine Execution
The machine component’s Machine Execution Settings de nes the schematic the machine will use. Starting a schematic requires a schematic asset.
Additional settings further specify the machine’s execution, which in uence the impact/e ect of the schematic’s execution individually and in context to other machines.
Execution Type
The machine’s Execution Type de nes how a machine is executed:
Single
The machine can be executed once at the same time.
I.e. it can’t be executed again while it’s already running.
Multi
The machine can be executed multiple times at the same time. Each execution will run it’s own, separate instance of the schematic.
Blocking
The machine can be executed once at the same time.
Other Blocking machines can’t be executed while the machine is running and the machine can’t start while another Blocking machine is running.
In short, only one Blocking machine can run at a time.
Update Type
The Update Type de nes in which Unity update function the machine will be updated:
Update
Each frame.
This is the default update function and should be used in most cases.
Late Update
Each frame after Update has been used by all components (and other machines). Best used for camera related things, e.g. when adjusting the camera to the player’s position.
This is due to the fact that Late Update is executed after Update, i.e. when the player has already been positioned for the frame.
Fixed Update
Each xed framerate frame.
Best used for physics related things, e.g. when dealing with rigidbodies.
Priority
You can optionally prioritize a machine, this will update a machine before other machines. When multiple machines are prioritized, they’re order descending by their Priority number, i.e. the machine with the highest priority number will be updated rst.
However, prioritized machines will start playing the schematic in the next frame, not in the frame they’re started (as not prioritized machines do). This is due to waiting for all prioritized machines that are started in a frame and ordering them according to their Priority number. I.e. a priority machine ensures starting before other priority machines with a lower priority.
E.g. 3 auto machines start when a scene is loaded: machine A, no priority
machine B, priority 0 machine C, priority 5
The machines will start playing the schematics in the following order:
machine A machine C machine B
Other Settings
There are additional settings that can be left alone in most cases.
Machine Type
The machine type is mainly used by Interaction type HUDs to e.g. show di erent HUDs for di erent machine types.
Machine types are created in Base/Control > Machine Types in the Makinom editor.
Stop On Destroy
If enabled, the machine’s schematic will be stopped when the machine’s game object is destroyed.
Machine End Action
This setting handles what will happen with the machine’s game object after the machine
nished executing the schematic.
Beside doing nothing, you can disable or destroy the game object.
Wait Time Settings
You can optionally use wait times before starting the schematic’s execution and before ending the machine’s execution state.
Object Turn Settings
You can optionally have the player face the machine and the machine face the player.
Auto Stop Machine
You can optionally automatically stop the schematic’s execution when the machine’s conditions are no longer valid.
Input ID
The machine can optionally use a de ned input ID instead of the game’s current input ID.
Input IDs are used by input keys to allow di erent input origins, e.g. for local multiplayer controls or control styles.
Actors
Game Object type actors added to the machine’s schematic can be selected in the machine’s settings. That’s the way to go in case you want to use a speci c game object in your scene.
The Actors settings are only displayed if a Game Object type actor has been added to the schematic.
Resource Overrides
Assets added to the machine’s schematic can be overridden by the machine. This further increases the reusability of schematics, as you can create more generic schematics that perform a task, but use di erent assets on di erent occasions.
The Resource Override settings are only displayed if resources like prefabs, audio clips or sprites are added to the schematic in it’s Settings node.
Example
Overriding the prefab resource in a Tagged Machine used to animate the death of enemies allows having particle e ects, e.g. a plant enemy spawning leafs while a human enemy spawns blood.
Condition Settings
If a machine is started is depending on the selected start type (there are di erent start types available in the di erent machine components, e.g. a trigger machine can start upon Trigger Enter, Trigger Stay and Trigger Exit) and optional conditions that will be checked. While some machine components have additional conditions that can be checked, the following conditions are available for most machines.
After adding conditions you’ll have the Auto Check setting available, which de nes when the conditions are checked.
Orientation
A machine can be started depending on the position of the machine and the starting object. You can check if the starting object is in front, back, left or right of the machine. E.g. you can make an interaction machine (e.g. opening a door) only able to start when the player is in front of the door.
This condition is not available for animation state machines.
Game State
Example
An interaction machine (e.g. displaying a dialogue) is only able to start while the game state In Control is active, which is set to only be active while the player can be controlled. This way, the interaction will only be available while the player is in control, i.e. it can’t be started during blocked control (e.g. in a cut-scene).
Variable
Starting a machine can depend on variables having certain values – variables and variable conditions allow creating advanced and complex game mechanics. You can learn more about variables here
Example
A trigger machine (e.g. starting a cut-scene or auto saving the game upon entering the trigger) is only able to start when the bool variable quest_A_started is enabled. The variable is enabled by another schematic, e.g. through a dialogue with an NPC.
Local Start Variables
A machine can initialize the local variables of the schematic it starts to de ned values. While you can also set them in the schematic, setting them in the machine allows reusing the schematic with di erent start variables, doing di erent things or behaving di erently.
Examples
An auto machine creating a tiled level with a random layout gets the level’s size from the local variables. Using two int variables (e.g. columns and rows) to de ne the size, you can create di erent level sizes with the same schematic. Level 1 can have a size of 8×8, level 2 a size of 10×8, etc.
A trigger machine will damage the player (reduce the health variable of the player) when he enters the trigger. Using an int variable (e.g. damage) to de ne the damage that will be done will allow using the scame chematic to do di erent damage on di erent machines.
Schematics can also de ne Machine Start Variables, local variables that will be exposed to machines for quick setup. The machine start variables of the schematic will also be listed here.
Change After Execution
Machines can automatically change variables after they nished execution. While you can also change variables in schematics, doing this in the machine allows reusing the schematic for
di erent purposes and changing di erent variables.
Examples
A trigger machine will add points to the player’s score (e.g. increase an int variable score) when he enters the trigger. To only get the points once, change the bool
variable points_A_collected after execution to true and use a variable condition checking for that variable to be false. Using a di erent variable for each points collection will make them unique and only be collectible once. Changing the variable in the schematic would change the same variable for all machines, requiring to have di erent schematics for every individual points collection.
A tagged machine will remove (kill) an enemy game object, playing an animation and an audio clip. The resource overrides allow reusing the schematic for di erent enemies and using di erent audio clips. To add a kill counter for di erent enemies (i.e. keep track of how many enemies of di erent types you’ve killed), increase di erent int variables for
di erent enemies (e.g. enemy type A increases enemy_A_counter, enemy type B
increases enemy_B_counter).
Machines, Schematics
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Editor Makinom Editor Overview
Makinom Editor Overview
Learn more about the Makinom editor.
The Makinom editor is used to de ne your game data and create schematics. The editor is separated into multiple sections and sub-sections.
Using the Editor
The Makinom editor is separated into di erent areas.
Sections
The sections are selected by the buttons at the top of the editor.
Sub-Sections
The sub-sections are selected by the button list at the left side of the editor.
The top of the sub-section area contains buttons to navigate backwards and forwards in the section/sub-section change history.
Help Text
The help text is displayed in the lower left corner of the editor.
Settings Area
The settings area uses the largest part of the editor (center+right side).
Depending on the selected section and sub-section, the settings area can be split up into a
Data List (listing the available data, e.g. input keys or UI boxes) and settings area.
Reload/Save Buttons
The changes are saved or the last saved state reloaded by the buttons at the bottom of the editor.
Jump List
The jump list allows quickly jumping to settings.
It can be shown or hidden using the icon in the top-right corner of the settings area.
The size of the di erent areas can be changed by the drag handles between them.
Opening the Editor
You can open the Makinom editor using the following methods:
Unity menu
Using the Unity Menu: Window > Makinom
Hotkeys
Windows: CTRL+ALT+M
Mac OSX: CMD+ALT+M
Makinom Project Asset
Either double click on a Makinom project asset le or select it and click on Open Project in the inspector.
This will open the Makinom editor and load the used project asset.
Schematic Asset
Either double click on a schematic asset le select it and click on Edit Schematic in the inspector.
This will open the Makinom editor, load the last used project and opens the schematic asset in the Schematics section.
Help Texts
There are help texts available for all settings in the Makinom editor. The help texts are displayed in the lower left corner of the editor.
By default, the help text of a setting is displayed when you hover with the mouse above the setting. This behaviour can be changed in the editor settings (Editor > Editor Settings).
Data Lists
Data lists are displayed in the settings area for sub-sections that allow creating multiple sets of data, e.g. input keys.
The data list is used to add, remove, copy and move data in the list. You can also search and sort the data list and, depending on the sub-section, lter the list.
Filtering is only available for data that has a type selection, e.g. formulas or scene objects.
Reorderable Lists
The data lists can easily be reordered by dragging the individual items.
There are also sorting options available in the Search, Filter & Sort foldout above the list items.
General Settings
Certain data lists (e.g. UI boxes) have General Settings to provide default setup that can be overridden by individual list items.
Data Selection Fields
The data selection elds are popups where you select data that you’ve created in the Makinom editor, e.g. selecting an Input Key.
Beside the popup, there are 2 small buttons available:
Add (green plus)
The add button will add a new set of data and select it in the eld.
E.g. if the eld is an Input Key selection, a new input key will be added.
Edit
The edit button will take you directly to the settings of the currently selected data.
E.g. if the eld is a Game State selection, it’ll open the selected game state’s settings.
The popup on the right of the small buttons is the asset source selection, de ning how the data’s asset will be referenced in this eld. See asset sources for more details.
Searchable Popups
All popup selections (e.g. for selecting data like input keys) are searchable.
Data selections also have sorting options and can optionally be divided into sub-lists in case the data has types (e.g. scene objects can be listed by scene object types).
Copy/Paste Settings
You can use a context menu to copy settings into the clipboard and paste them on other, compatible settings.
Which settings are part of the copied data are highlighted by a blue color (the color can be changed in Editor > Editor Settings).
This can be useful if you have to redo the same setup on multiple things, even if you need to change a setting or 2 of the copied setup.
The settings stored in the clipboard will stay as they are when they where copied, even if you change the settings you copied.
Depending on the settings, this can also be used to copy some individual elds/settings instead of a whole setup, e.g. value elds:
Language Content
Learn more about language content de nition and language export/import functionality in the
languages documentation.
Sections
The Makinom editor is separated into the following sections:
Editor Base/Control Game
UI
Templates Schematics
See below for more details on the di erent sections and their sub-sections.
Editor
The Editor section contains mostly settings and informations related to the Makinom editor. Learn more about it here.
Base/Control
The Base/Control section contains the settings related to control and basic game data. Learn more about it here.
Game
The Game section contains the settings related to the game (e.g. game states, languages) and that are used in your game world (e.g. formulas, camera positions, scene objects).
Learn more about it here.
UI
The UI section contains the settings related to UI and save games. Learn more about it here.
Templates
The Templates section contains the settings for all kinds of templates that are used by Makinom.
Learn more about it here.
Schematics
The Schematics section is used to create and edit schematics. Schematics are edited using the
node editor.
Learn more in the schematics documentation.
Saving Settings
Saving the editor settings (via Save Settings button in the bottom right) will list the changed settings.
It’ll show removed data ([-]), newly added data ([+]) and settings that have changed.
Beside listing the changes, it’ll o er additional options for updating data in your Unity project.
Create Backup
Enabling this will create a backup of the previous setup. Backups will package everything in the Makinom data folder (Assets/Gaming Is Love/_Data/) into a unitypackage le.
Backups can be restored via Editor > Backups in the Makinom editor.
Data Updates
Certain changes in the Makinom editor can make it necessary to update other content in your Unity project.
This mainly happens when changing the GUID of a list content (e.g. an input key) or removing a list content (e.g. a variable change template). The update options are only available if an update is needed.
Update Schematics
Enabling this will update all schematics in your project (optionally limited to schematics within a folder and it’s sub-folders).
Update Prefabs
Enabling this will update data in components on your prefabs.
Update Scenes
Enabling this will update data in components in your scenes.
This will close the current scene and open every scene in added in your Unity build settings.
Updated on October 7, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Editor Node Editor
Node Editor
Learn more about the node editor.
The node editor is part of the Makinom editor and is used to create schematics and formulas.
While this documentation focuses on schematics, most of the features are also available in formulas (unless mentioned otherwise).
The node editor is separated into 2 parts – the settings area and the node grid. The position of the settings area when editing schematics can be changed in the Makinom editor (Editor > Editor Settings) by the Schematic Editor Menu.
Settings Area
The settings area displays the settings of the currently selected node.
Schematic Settings Area
When editing schematics, the settings area also displays the editor help and buttons to create new schematics or open existing scematics. At the bottom of the editor you’ll nd buttons to save or delete the schematic asset instead of the project save buttons. When using Save Schematic As … you can save an existing schematic using a new name.
Node Grid
The node grid is used to add, move, connect and delete nodes. At the top of the node grid, you can see a button bar that is used to manage the nodes – you can also do this with the context menu (right mouse click).
You can navigate on the grid by clicking and dragging the scroll wheel (or middle mouse button).
Button Bar
The button bar contains functionality to manage your nodes.
From left to right, the buttons are:
Show Settings
Shows or hides the settings area.
Show Grid
Shows or hides the grid background.
Snap to Grid
Toggles if nodes will be placed neatly when moving them on and o .
Colorize Nodes
Toggles if nodes are colorized on and o .
The nodes are tintend using the colors de ned in Editor > Editor Settings.
Enable/Disable Node
Toggles the checkbox to enable/disable nodes in the upper right corner of a node on or o .
Merge Single Slot
If enabled it’ll merge the info and slot of single slot nodes.
Sort Horizontally
Sorts the nodes horizontally from the selected node onwards.
If no node is selected, all nodes will be sorted starting from the Settings node (start node).
Sort Vertically
Sorts the nodes vertically from the selected node onwards.
If no node is selected, all nodes will be sorted starting from the Settings node (start node).
Place on Grid
Places all nodes neatly on the grid.
Add Node
Displays a menu to add nodes.
The nodes are separated into several sub-menus (e.g. Inputs, Machines, etc.).
If a node is selected, the node will be added as next node to the selected slot or the rst free slot of the node.
If no node is selected, the node will be added without a connection.
Copy
Copies the selected node and adds it without a connection.
Copy to Clipboard
Copies the node to the clipboard.
Paste from Clipboard
Pastes the a node copied to the clipboard.
If a node is selected, the node will be added as next node to the selected slot or the rst free slot of the node.
If no node is selected, the node will be added without a connection.
Paste Settings
Pastes the settings of a copied node on a selected node.
Remove Node
Removes the selected node.
Remove Chain
Removes the selected node and all following (connected) nodes.
+/- Slider
Zooms the node grid.
You can also zoom using the scroll wheel.
Search Bar
Allows searching for nodes by node name.
All non-matching nodes will be semi-transparent, making it easier to see the nodes you’re looking for.
Layer Selection
Allows changing the current layer, adding new layers or renaming a layer.
Searchable Nodes
Looking for a speci c node? Use the search bar to highlight nodes!
Zooming
You can zoom in/out using the zoom slider in the button bar or the scroll wheel.
Node Layers
The node layer selection is located at the right side of the button bar. You can use node layers to bring order into your schematic by separating them on di erent layers.
The node layer popup also allows adding new nodes by selecting Add New Node. You can change the name of a layer by clicking on the Rename Layer button on the right side of the popup – this changes the node layer popup into a text eld. To stop editing the name, click on the Rename Layer button again.
To remove a layer, click on the Remove Layer button – this will remove the layer and all nodes (and layer gates) to it.
To connect nodes between layers, you can add Layer Gate nodes.
A Layer Gate node is visible on both layers that are connected by it. On the layer the connection starts, a Gate Entry node is displayed. On the layer the connection the connection ends, a Gate Exit node is displayed.
You can also move nodes and node changes between layers using the context menu. Double clicking on a Gate Entry or Gate Exit title will take you to the layer it connects to.
Anatomy of a Node
A node consists of 3 parts – title, info and slots.
Title
The name/title of the node is displayed at the top of the node (darker area of the node). Double clicking on the node’s title will limit the node grid view to only display the node and following nodes (node chain).
To leave the limited view, either double click on the title again or double click somewhere on the grid.
Hovering the mouse above the title will display the help text of the node. You can move the node by dragging it after clicking on the title.
Info
The info of the node displays parts of the settings made in the node.
The info text is displayed below the title – hovering the mouse above it will display the info text in the help text (displays more text).
Slots
The slots are used to connect nodes – depending on the node you’ll have 0, 1 or multiple slots.
A connected slot will have a green circle. A not connected slot will have a red circle.
To change a node’s settings, select it by clicking on it. The settings area will display the node’s settings.
You might have noticed the small checkbox in the upper right corner of the node – this allows you to quickly enable or disable the node (the checkbox can be turned on/o in the button bar).
Connecting Nodes
Nodes are connected by clicking and holding the left mouse button on a slot. Drag the line on another node and release the mouse button above the node. You can also double click on a slot and click on another node to connect them.
Connections can be removed through the context menu when right clicking on a slot and selecting Remove Connection.
Context Menu
The context menu is opened by a click on the right/context mouse button. Depending on where you’ve clicked, you will have di erent options available.
Like the all other popups, the node editor’s context menu is also searchable.
Click on Grid
Right clicking on the grid will allow:
Adding nodes without connecting them. Adding node groups.
Paste a node from the clipboard (works like adding a new node). Sort all nodes horizontally or vertically.
Snap all nodes to the grid.
Click on Node
Right clicking on a node (title/info) will allow:
Adding nodes connected to the rst free slot of the node.
When there is no free slot, connects the node to the rst slot and the previously connected node to the new node’s rst slot.
Add the node to a new or existing node group. Copy the node or copy it to the clipboard.
Paste a node or node settings from the clipboard. Removing the node or node chain.
Sorting the node and all following nodes (chain) horizontally or vertically. Snap the node and all following nodes (chain) to the grid.
Move the node and all following nodes to a di erent node layer.
This will automatically create a Layer Gate node and connect it to the previous node. Limit the node view (same as double clicking on the title) or view all nodes.
Click on Slot
Right clicking on a slot will allow:
Adding nodes connected to the slot.
When there already is a connection, the new node will be connected to the slot and the previously connected node to the new node’s rst slot.
Add the node to a new or existing node group. Copy the node or copy it to the clipboard.
Paste a node or node settings from the clipboard. Removing the slot’s connection.
Removing the node or node chain.
Sorting the node and all following nodes (chain) horizontally or vertically. Snap the node and all following nodes (chain) to the grid.
Move the node and all following nodes to a di erent node layer.
This will automatically create a Layer Gate node and connect it to the previous node. Limit the node view (same as double clicking on the title) or view all nodes.
Box Selection
You can use box selection to select multiple nodes.
Using Shift+Click also lets you select multiple nodes.
Node Groups
Use Node Groups to bring order into your node-chaos. You can also put groups into groups, into groups, into groups …
You can add or remove nodes (and groups) to/from groups by holding CTRL while dragging them – or use the context menu.
Keyboard Shortcuts
There are several keyboard shortcuts available:
CTRL+F
Focus on the search eld.
CTRL+D
Duplicate a node.
CTRL+C
Copy a node to the clipboard.
CTRL+V
Paste a node from the clipboard.
CTRL+X
Cut (i.e. copy to clipboard and remove) a node.
CTRL+G
Create a node group (adding selected nodes to it).
F
Focus/scroll on the selected node(s).
Delete
Delete the selected nodes.
Live Debugging (Schematics only)
Want to know what your running schematics are doing? Try live debugging them and see which nodes are executed, the values they’re using and which variable changes they cause.
Debug information will be collected when the Makinom editor is open while playing. You can also enable Auto Debug Schematics in Editor > Editor Settings > Node Editor Settings to always collect the debug information, even if the editor is closed.
Debugging is only used when playing in the Unity editor, i.e. built games are not impacted by it.
You can directly start debugging a machine’s schematic by clicking on the Edit Schematic button in the machine’s inspector while it’s running. Having a schematic open in the node editor will also list all available running or already stopped schematics that are using the same schematic asset.
See the image (and explanations) below for more details on the debugging features.
Debugging Available
Lists all available schematics (running and already stopped) for the open schematic asset. Start/stop debugging via the button of each entry.
Debug Info
When having a node selected, the debug info shows if the node has already been executed (and at which index) and the variable changes the node caused.
If the node has a wait time, it’ll also show this information.
Debug Value
Shows the debug value(s) of string, oat, bool and Vector3 value selections.
Executed Node
Nodes that have already been executed are marked with a yellow border. The color can be changed in Editor > Editor Settings.
Current Node
The node the execution is currently at is marked with an orange border. The color can be changed in Editor > Editor Settings.
Breakpoint
Nodes that have a breakpoint set will be marked with a red circle in their upper left corner. You can set a breakpoint via the Breakpoint button in the node’s settings.
Unity will pause when reaching a breakpoint node – due to the fast execution between
nodes, that might still execute additional nodes after the breakpoint node until Unity paused the game.
You can also change the schematic while it’s running, e.g. changing a connection or adding/removing nodes. This’ll change all schematics that use the same asset, not just the one you’re currently debugging. To make the changes permanent, you need to save the schematic.
Please note that exiting play mode (i.e. stopping the game in the Unity editor) will lead to losing the debug values once you open a di erent schematic asset.
Editor, Schematics
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Advanced Topics Performance Optimizations
Performance Optimizations
Learn how you can improve the performance of your game.
While Makinom is already optimized for performance, you can use additional tweaks and techniques to further improve your game’s performance. Naturally, this depends on how you’re using Makinom’s features and on other factors, like your target platform.
It’s recommended to use Unity’s pro ler (Unity menu: Window > Profiler or Window >
Analysis > Profiler) to check which optimizations are bene cial for your game. Keep in mind that the pro ler can also in uence the outcome.
Pooling
Creating objects (e.g. game objects or data holding structures) and freeing their memory after use is costly – preventing this through pooling can improve the performance of your game.
Pooling Game Objects
Instantiating and destroying game objects can decrease the performance of your game, especially when happening often. This can be reduced by using pooling.
It’s not a good idea to pool every game object – e.g. level architecture or other game objects that are only needed once in the scene. Pooling is only useful for game objects that are often used (instantiated and destroyed), like particle e ects or bullets.
Pooling of game objects is set up in Base/Control > Game Object Pools and added to scenes using the Pool component.
Learn more in the pooling documentation.
Pooling Lists
Lists are widely used in Makinom, e.g. changing and checking game variables often involves a list of the used variable handlers, or using game objects in schematics also often involve lists of game objects. Creating lists and freeing their used memory after use can also in uence performance, particularly when done very often each frame frame.
Makinom automatically reuses lists where possible – i.e. once a list is no longer needed, it’ll be returned to a pool of lists and reused at another time. This improves performance, but also increases the required memory.
You can change the list pooling settings in the Makinom editor (Game > Game Settings > Performance Settings). To disable pooling, set the pool size of the individual lists to 0.
Use the Trim Excess option with caution – while this frees the memory occupied by larger lists to reduce the total amount of allocated memory of your game, this will have an impact
on performance if it happens often. Only use this option when you’re running into a problem with using too much memory (or reduce the number of pooled lists). Trim Excess is by default disabled.
Machines and Schematics
Starting schematics through machines or schematic nodes is optimized for fast and performant execution, but can still have a large impact on performance when starting a lot of machines at the same time (e.g. using a Start Machine node). While Makinom does a lot of optimizations
under the hood, there are some things and settings to consider on your end to further improve the performance.
Please note that the in uence of these tips on the performance largly depend on your use of Makinom’s features and your target platform. In a simple or light setup without many machines running at the same time, you’ll barely notice the improvements – but when starting/running hundreds or thousands of machines at the same time, you’ll notice the impact these settings can have.
Sharing Local Variables
When starting machines/schematics from a schematic using a Start Machine or Start Tagged Machine node, you can optionally share the local variables of the running schematic with the started schematics/machines. Unless there’s a reason not to do this (e.g. they’re using the same variable keys but you don’t want the started schematics to override the running schematic’s variables), it’s recommended to share the local variables. Otherwise each started machine would have their own variable handling, which impacts performance.
If none of the involved schematics use local variables, this can be ignored, as the local variable handler of a schematic is only created upon using variables.
Sharing Local Selected Data
Like local variables, selected data lists of the running schematic can be shared with the started machines/schematics when using a Start Machine node. This also improves performance and is recommended, unless you don’t want the selected data to be shared (e.g. to prevent interference between the schematics).
If none of the involved schematics use selected data, this can be ignored, as the local selected data handler of a schematic is only created upon using selected data.
Repeat Schematic Node
The Repeat Schematic node is very useful for schematics/machines that repeat execution every frame, e.g. Tick Machines or Auto Machines using Repeat Execution. Starting a machine is more costly than repeating a running schematic.
This node will repeat executing the running schematic from the start in the next frame (or FixedUpdate depending on the machine’s update type). This will perform far better than having
a Tick Machine start the schematic each frame. If the machine should only run under certain conditions, you can use the Auto Stop settings in the machine component to stop the schematic when the conditions aren’t valid any longer. Additionally, you can use a Check Start Condition node in the schematic to check the machine’s starting conditions.
Single vs Multi
The Execution Type of a machine (and machine starting nodes) can also impact performance. Single execution will perform better than Multi execution, because Multi needs it’s own instance of the schematic for each simultaneously running machine.
If the used schematic doesn’t involve anything with time (e.g. a Wait node or waiting for a node to nish), all nodes will be executed within the same frame, making Multi execution not neccessary (because the schematic already nished executing before the next machine could start).
E.g. starting 1000 machines using a Start Machine node will perform far better with Single execution than it would with Multi execution.
The Blocking execution type is the same as single (but preventing other Blocking machines from executing).
Limit Nodes per Tick
The Limit Nodes per Tick setting in the schematic’s Settings node can optionally limit the number of nodes that will be performed in a single frame. Once the number of nodes is reached, the schematic will wait until the next frame before continuing with the next node’s execution.
Naturally, any node involving wait times will reset the node counter.
Executing many nodes per frame means more impact on the overall processing and can impact performance. If you’ve got some task-heavy schematics, it might help limiting the nodes per frame to reduce the stress on the system.
This can also help when starting a lot of machines/schematics in Multi execution type. Keep in mind that the node limit is per executing schematic, i.e. it should be low enough to actually limit the used nodes per frame.
Share This Article :
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Pooling
Pooling
Game object pooling can be used to increase the performance of your game – learn more about it and when to use it.
Instantiating and destroying game objects can decrease the performance of your game, especially when happening often. This can be reduced by using pooling.
Using Pooling
Pooling is a technique that will instantiate a pool of game objects when a level was loaded and only enables and disables them afterwards instead of destroying them and instantiating new objects. Usually, this will help increasing the performance, but it can depend on the use case if it actually helps or has negative e ects, since having a lot of game objects alive in a pool (even disabled) also costs memory.
When to use Pooling
As said, pooling costs memory for holding the game objects, but increases the performance by removing the heavy instantiation and destruction of game objects.
You should use pooling when game objects are often created and destroyed, e.g.:
ring projectiles, missiles, etc. reappearing enemies
You shouldn’t use pooling for things like level architecture or procedurally generated levels, since those will most likely only be instantiated once and not destroyed until the level ends.
Example
E.g. the missiles red by the player’s ship in a vertical space shooter are pooled. The player’s re rate and the time a missile will be alive result in a maximum of about 15 missiles to be alive at the same time.
The pool size is 20 – this is a good use of a pool, but can also be reduced a bit. The pool size is 100 – this is a waste of memory.
Game Object Pools
Game object pools are set up in Base/Control > Game Object Pools.
A game object pool is based on a prefab and instantiates it when a level was loaded. The Start Size of the pool de nes the quantity of game objects that will be created at the start of a
level. Pools can optionally grow by enabling Can Grow in the pool’s settings – this will add more game objects to the pool when needed and keeps them alive, otherwise game objects exceeding the pool will be destroyed again.
The pooled objects can be used by the prefabs de ned in schematics. It’s only used when the prefab is de ned as a resource in the schematic’s settings and has using pooling enabled. The prefab in the schematic and the pool must be the same prefab. If that’s the case, spawning and destroying a prefab in the schematic will get a game object from the pool and enable/disable it instead of instantiating and destroying it.
Example
The prefab missile is pooled with a start size of 10 and can grow.
The player’s control is handled by a schematic using the missile prefab as a resource with Use Pooling enabled. The same prefab as the pooled prefab is used, i.e. spawning this prefab will use a pooled game object.
The level starts and 10 missile prefabs are instantiated and disabled immediately. The player res missiles, they’re placed at the player’s position and enabled (Spawn Prefab node). When they hit a target or leave the screen, they’re disabled (Destroy Prefab node).
If the pool runs out of missiles, new missiles will be instantiated and added to the pool (i.e. they’ll also be enabled/disabled when used).
Pool Component
The Pool component is used to add a game object pool to a scene.
It’ll instantiate the selected pool’s prefab when the level was loaded (or when the component is added to the scene in a running game, e.g. spawning pools via prefabs).
Pools are only used in the scene they where added to, i.e. you need to add them to each scene they should be used in.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Render Machine
Render Machine
Learn more about render machines and what you can use them for.
Render machines are Unity components that are added to game objects. They’re mostly used for game logic related to rendering, e.g. objects becoming visible/invisible to the camera.
A render machine component can be added through the components menu (Makinom > Machines > Render Machine) or the scene wizard (Add Machine > Render Machine). A game object with a render machine is represented in the Unity scene view by this gizmo icon:
You can learn more about machine components in general and their basic settings here.
Start Types
A render machine is started by renderer and camera callback functions.
Became Invisible
Started when the machine’s game object is no longer visible by any camera. It’s implemented in the component’s OnBecameInvisible function.
Example
This start type can be used to disable game objects that are no longer visible. Use a Activate Object node to enable or disable a game object.
Became Visible
Started when the machine’s game object became visible by any camera. It’s implemented in the component’s OnBecameVisible function.
Example
This start type can be used to add a visible object to a HUD’s user list. Use a Call HUD
node to add users to a HUD.
Pre Render
Started before a camera starts rendering the scene and if the machine is attached to a camera. It’s implemented in the component’s OnPreRender function.
If you want to change the camera’s viewing parameters, do this in Pre Cull instead.
Example
This start type can be used to make nal adjustments to the camera before rendering. Use a Change Camera Options node to change settings of the camera.
Post Render
Started after a camera nished rendering the scene and if the machine is attached to a camera. It’s implemented in the component’s OnPostRender function.
Example
This start type can be used to reset camera adjustments after rendering. Use a Change Camera Options node to change settings of the camera.
Pre Cull
Started before the camera culls the scene. It’s implemented in the component’s OnPreCull function.
Culling determines which objects are visible to the camera.
Example
This start type can be used to make nal adjustments to the camera before rendering. Use a Change Camera Options node to change settings of the camera.
Will Render Object
Started once for each camera the machine’s game object is visible in during culling. It’s implemented in the component’s OnWillRenderObject function.
Example
This start type can be used to make nal adjustments to the game object. E.g. use a Change Color node to change the game object’s color.
Render Object
Started after the camera has rendered the scene, similar to Post Render, but used on all game objects not only cameras. It’s implemented in the component’s OnRenderObject function.
Example
This start type can be used to reset adjustments on a game object. E.g. use a Change Color node to change the game object’s color back.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Save Games
Save Games
Makinom handles saving and loading the game for you.
Saving the player’s progress is mandatory for most games. Makinom includes a complete save game system that will save and load game data. Save games can either be saved actively by the player selecting a save game le, or by using Auto Save Slots to automatically save the progress to a previously selected slot.
The save game system can be expanded to save custom data (e.g. from 3rd party products) with the regular save data by adding Custom Save Data.
Using Save Games
The save game system is accessed through schematics. Saving, loading and displaying save game menus is handled by nodes (found in Add Node > Game > Save Game).
The settings for the save game systems can be found in the Makinom editor in UI > Save Game Settings.
What will be saved
The save game system can save the following data in a save game:
Game Time
The current game time.
The game time is the time since the player started a New Game, i.e. using a Start Game node.
Player Position
The current scene, position and rotation of the player.
The position and rotation can only be saved when a player is set.
Respawning the player when loading the game is only possible when you’ve de ned a player prefab in the Makinom editor (Game > Game Settings).
Music
The currently playing music and track position.
Block States
The currently blocked input keys and HUDs.
Variables
The global and object variables (non-local).
You can optionally exclude de ned variable keys from being saved, or only save de ned variable keys.
Terrain Changes
Changes made to terrains (via schematics) can also be saved with save games. Please note that this’ll dramatically increase the size of a save game.
All data is saved optionally, i.e. you can enable/disable which data should be saved in the Makinom editor. By default, everything will be saved (except terrain changes).
Save games don’t save the current state of the scene (e..g positions of all game objects, spawned prefabs, etc.) or running machines/schematics.
Saving
Save games are stored as XML-formatted text and can optionally be encrypted.
Save File Locations
Save games can be stored in di erent locataions.
The location of les and PlayerPrefs vary based on the operating system and the company/game name you’ve de ned in Unity. E.g. in Windows, the les are stored in sub-
folders of the user’s folder and the PlayerPrefs are stored in the registry.
You can also create custom save le handling by deriving your class from BaseSaveGameFileHandler, e.g. if you want to implement save games for a game console.
Custom
Uses a custom save game solution using static functions to save, load and delete save games.
Data Path
Save games are stored as les in Application.dataPath.
Persistent Data Path
Save games are stored as les in Application.persistentDataPath.
PlayerPrefs
Save games are stored in Unity’s PlayerPrefs.
Save Menu
The player can actively save the game by using a Save Game Menu node displaying the Save menu type. The save menu will display a list of available save game les the player can save to.
The save menu and number of available save game les are de ned in the save game settings.
Auto Save Slots
You can automatically save the game by using an Auto Save node. The auto save node will automatically save to the current auto save slot or store the save game as Retry save data. A retry save game will only be available while the application is running. Once the player closes the game, the retry save game will be gone.
Using Auto Save Slots still requires to actively save the game, e.g. via schematics used by an interaction (like a save point) or by passing through a checkpoint (e.g. using a Trigger Machine).
The player can optionally select an auto save slot that should be used using the Auto Save Slot Dialogue node. This allows multiple players to use auto saving without overriding each other’s save games.
The number of available auto save slots are de ned in the save game settings.
Loading
The player can load the game when a save game is available or retry data has been saved.
Load Menu
The player can actively load the game by using a Save Game Menu node displaying the Load menu type. The load menu will display a list of available save games (including auto save slots).
The load menu is de ned in the save game settings.
Auto Load
Loading the game using an Auto Load node will load the save game stored in the current auto save slot or retry save game (if available) without the player selecting a le.
This can be used to e.g. automatically return to the last auto save upon game over or adding a Continue option in a start game menu (e.g. via Show Dialogue node).
Custom Save Data
Makinom allows you to add custom save data to the save game system.
Add custom save data (e.g. 3rd party product data) to Makinom save games by registering a class (e.g. a component) to the save game system. The class must implement the ISaveData
interface.
Learn more about this in the custom save data documentation. Editor, UI
Updated on January 19, 2021
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Saving Game Objects
Saving Game Objects
Optionally save information about spawned prefabs or placed game objects in your scenes. This information can be saved and restored between scene changes and in save games.
There’s a di erence between saving spawned prefabs and game objects already placed in your scenes. Spawned prefabs use Prefab Savers, placed game objects use Game Object Savers.
Saving Content
Both Prefab Savers and Game Object Savers can save the same content and are saved/loaded similarly. The following information applies to both of them.
What is saved?
Both prefab savers and game object savers can save the same content:
position rotation scale
local variables
You can also save this information for all child objects of the saved game object.
Additionally, any component attached to the game object (and it’s child objects) implementing the IComponentSaveData interface will be saved as well. See this documentation for more details.
When is it saved?
A game object’s data is saved when it is destroyed. This also includes when it’s destroyed by changing scenes.
If the data is also saved with save games, all (saving) game objects of the current scene will store their data as well.
When is it loaded?
The data is loaded when the scene is loaded.
Save Games
To save prefab saver or game object saver data with save games, you need to set up saving them in UI > Save Game Settings. You can save the data from all scenes or only the current scene – and automatically remove data from a scene after a de ned number of scene changes (without returning to the scene).
Prefab Savers
Prefab savers are used to store information of spawned prefab instances. Saved prefab instances will be respawned and load the stored data when the scene is loaded.
Prefab savers are set up in Base/Control > Prefab Savers. To be able to save information about a spawned prefab, it must match one of the set up prefab saver’s prefab.
Adding Prefabs Instances
Prefab instances need to be added to the prefab savers in order to save them.
This is done in the Spawn Prefab node in schematics, by enabling the Add Prefab Saver setting. This setting is disabled by default, not using prefab savers.
Prefab instances that are added to a prefab saver will save their content when they are destroyed, i.e. also when changing scenes.
Removing Prefab Instances
Destroying the prefab instance will save it’s content, respawning it when the player reloads the scene.
To prevent this, the Destroy Prefab and Destroy Object nodes in schematics have the Remove Prefab Saver setting. This setting is enabled by default, removing the destroyed game object from prefab savers.
You can also remove an instance without destroying it using the Remove From Prefab Saver node. Beside removing a single instance, it can also remove all instances of a prefab saver, or all prefab savers in the scene.
The Clear Prefab Savers node can remove all prefab data from a scene or all scene.
Game Object Savers
Game object savers are used to store information of game objects already placed in your scene’s setup, i.e. not spawned during play. Their information will be restored when the scene is loaded.
They’re only used to save/load information like position or component data – they don’t handle enabling/disabling or destroying a game object. For this, use e.g. a Game Object Manager component to enable/disable a game object based on de ned conditions.
Game Object Saver Component
To save a game object’s information, add a Game Object Saver component.
The di erent game objects are identi ed by their Scene GUID, de ned in the component. A random GUID is generated when the component is added. If two game objects use the same GUID, they’ll also share the data.
When the component’s game object is destroyed (also when changing scenes), the content will be saved.
When loading a scene, the component will get it’s data based on the Scene GUID, loading the stored information (e.g. position).
Removing Game Object Saver Data
Unlike prefab savers, game object savers can’t be added or removed. If a game object of your scene setup uses it, it’ll keep using it.
However, you can use the Clear Game Object Savers node in schematics to remove the game object saver data from a scene or all scenes.
Updated on June 30, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Scene Objects
Scene Objects
Scene objects can be used to add information to the game objects in your scenes.
Add content information like names, descriptions, icons or portraits. This can be used to name NPCs, doors leading somewhere or any other kind of game object.
HUDs and dialogues can display the information.
Scene Object Types
Scene object types are used to organize and lter scene objects and can add additional type information to them.
They’re set up in Game > Scene Object Types.
Cursor Changes
Scene object types can change the cursor texture while the cursor is over a game object with a scene object of the type attached.
A scene object’s own cursor changes will overrule the type’s cursor changes.
Object Variables
Scene object types can automatically add Object Variable components to the game objects they’re added to (via the scene object using the type).
This also allows setting the object ID for the variables (or use them in local mode) and initialize default values.
Scene objects can optionally overrule this with their own object variables settings.
Portraits
You can add portraits to your scene object types. Portraits can be shown by HUDs and dialogues.
A scene object can overrule the portraits of it’s scene object type by de ning a portrait for the same portrait type.
Custom Text Codes
Custom text codes can be used to add customizable information to the texts of scene objects and scene object types (e.g. name or description), or dialogues that use a speaker with a scene object.
A scene object’s and scene object component’s own custom text codes will overrule the type’s text codes.
Scene Objects
Scene objects are used to add information to game objects in your scenes using a Scene Object Component.
They’re set up in the ORK Framework editor in Game > Scene Objects.
Cursor Changes
Scene objects can change the cursor texture while the cursor is over a game object with it attached.
This will overrule overrule the scene object type’s cursor changes.
Object Variables
Scene objects can overrule their scene object type’s object variables settings and automatically add Object Variable components to the game objects they’re added to.
This also allows setting the object ID for the variables (or use them in local mode) and initialize default values.
Portraits
You can add portraits to your scene objects. Portraits can be shown by HUDs and dialogues.
A scene object can overrule the portraits of it’s scene object type by de ning a portrait for the same portrait type.
Custom Text Codes
Custom text codes can be used to add customizable information to the texts of scene objects and scene object types (e.g. name or description), or dialogues that use a speaker with a scene object.
A scene object component’s own custom text codes will overrule the scene object’s and scene object type’s text codes.
Scene Object Component
Scene object information can be added to game objects using a Scene Object Component.
Once that information is attached to the game object, it can be used by di erent features, e.g.:
Interaction HUDs can use the scene object attached to the displayed interaction’s game object
Tooltip HUDs can show tooltips for game objects with an attached scene object schematic actors can use it in dialogues
You don’t need to set up scene object data for each game object in your game that needs information – only for each game object that needs di erent information.
Your game has wooden and metal doors. A scene contains 5 doors, 3 wooden and 2
metal doors.
You’ll need 2 di erent scene objects – one with the wooden door information (e.g.
name Wooden Door) and one with the metal door information (e.g. name Metal Door).
As you can see in this example, all game objects that share the same information can use the same scene object. On the other hand, if you need individual information on game objects, you need to set up individual scene objects for them.
Your game has 3 unique NPCs named Red, Green, and Blue. You’ll need to set up scene objects for all 3 of them.
Text Codes
You can add additional text codes to scene object components.
The component’s text codes will overrule text codes de ned in scene objects or scene object types, i.e. de ning the same text code with a di erent value will use the value from the component.
This can be used to individualize parts of the scene object information.
Your game’s doors from before (wooden and metal) display additional information about
where they’re leading to using text codes.
The wooden door‘s name is Wooden Door to <destination> and the metal door‘s name
is Metal Door to <destination>.
The scene object components adding the scene object to game objects in your scene add a text code for <destination>, de ning the name of the destination. E.g. a wooden door with the <destination> text code Inn will display Wooden Door to Inn.
Share This Article :
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Schematic Nodes
Schematic Nodes
A list of all available nodes for schematics.
Learn more about schematics in this documentation. There are currently 462 schematic nodes available (excluding nodes from extensions, e.g. ORK Framework).
Animation
Animation Template
Plays or stops an animation template on a game object.
Animation/Fade
Change UI Color
Changes or fades the color of a UI box, HUD, ying text or anything implementing the ‘IColorFadeable’ interface stored in selected data.
Fading can either fade to a color, ash to a color and back, start blinking to a color and back or stop all fading.
Change UI O set
Changes or fades the animation o set of a UI box, HUD, ying text or anything implementing the ‘IUIAnimation’ interface stored in selected data.
Use this to e.g. move in a UI box from a side to it’s original position.
Shake UI O set
Shakes a UI box, HUD, ying text or anything implementing the ‘IUIAnimation’ interface stored in selected data.
Shaking uses the animation o set of the UI (same as ‘Change UI O set’ node).
Change UI Scale
Changes or fades the scale factor of a UI box, HUD, ying text or anything implementing the ‘IUIAnimation’ interface stored in selected data.
Fade Screen
Fades the screen.
Set Screen Color
Set’s the screen fade color, canceling all ongoing screen fades.
Change Color
Changes or fades the color of renderers, lights or color elds/properties.
Fading can either fade to a color, ash to a color and back, start blinking to a color and back or stop all fading.
Animation/Legacy Animation
Play Legacy Animation
Plays or stops a legacy animation on a game object.
Rewind Animation
Rewinds an animation clip or all animations of a game object.
Is Animation Playing
Checks if a de ned animation clip is playing.
If the animation clip is playing, ‘Success’ will be executed, otherwise ‘Failed’.
Animation Culling Type
Changes the culling type of the animation component.
Animation Layer
Changes the layer of an animation clip.
Animation Speed
Changes the speed of an animation clip.
Animation Time
Changes the time of an animation clip.
Animation Weight
Changes the weight of an animation clip.
Animation Wrap Mode
Changes the wrap mode of an animation clip or animation component.
Animation Blend Mode
Changes the blend mode of an animation clip.
Add Mixing Transform
Adds a transform that should be animated to an animation clip.
Remove Mixing Transform
Removes a transform that shouldn’t be animated from an animation clip.
Store Animation Value
Stores a value of an animation clip into a oat variable.
Animation/Mecanim
Play Mecanim Animation
Changes parameters of a mecanim animator on a game object.
Animator Speed
Changes the speed of the animator of a game object.
Animator Culling Mode
Changes the culling mode of the animator of a game object.
Animator Update Mode
Changes the update mode of the animator of a game object.
Animator Feet Pivot
Changes the feet pivot of the animator of a game object.
Animator Weight
Changes the a weight value of the animator of a game object.
Animator Set Vector3
Changes the position or rotation of the body or root of the animator of a game object.
Animator Get Vector3
Stores a Vector3 value of an animator into a Vector3 variable (e.g. the position of an IK goal).
Animator Rebind
Rebinds all the animated properties and mesh data with the animator of a game object.
Animator Update
Evaluates the animator of a game object based on delta time.
Animator Target
Sets the target of the animator of a game object.
Get Bone Transform
Uses a bone transform of an animator and uses it to change selected data.
Selected data can be used to store di erent data, e.g. a game object or a list of game objects.
Store Parameter
Stores a parameter of an animator into a variable.
Change Animator Controller
Change the animator controller used by a game object’s ‘Animator’ component. Supports animator controllers and animator override controllers.
Apply Builtin Root Motion
Apply an ‘Animator’ component’s built-in root motion.
Use this in schematics started by the ‘Animator Move’ start type of ‘Animation Machine’ components or the ‘State Move’ start type of ‘Animator State Machine’ components to use the default root motion.
Animation/Playable
Change Director State
Changes the state of ‘Playable Director’ components. Plays, pauses, resumes or stops playback of a director.
Change Director Asset
Changes the playable asset of ‘Playable Director’ components.
Is Director Playing
Checks if ‘Playable Director’ components are playing.
If a director is playing, ‘Is Playing’ will be executed, otherwise ‘Not Playing’.
Change Director Time
Changes the state of ‘Playable Director’ components.
Store Director Time
Stores a time value of a ‘Playable Director’ component into a oat variable.
Change Director Update Mode
Changes the time update mode of ‘Playable Director’ components.
Change Director Wrap Mode
Changes the wrap mode of ‘Playable Director’ components.
Audio
Pause Audio Listeners
Pauses or unpauses all audio listeners in the scene.
Uses ‘AudioListener.pause’ to pause/unpause audio listener components.
Audio/Audio
Change Music Volume
Changes the music volume – either sets or fades the volume.
This changes the overall music volume, not the volume of the playing clip.
Play Sound
Plays a sound.
If no AudioSource component is added to the game object, a new one will be added automatically.
Play Sound At Point
Plays a sound at a de ned position.
This will create an audio source at the position and disposes of it afterwards.
Stop Sound
Stops a sound.
Play Sound (Channel)
Plays a sound on a sound channel.
Stop Sound (Channel)
Stops a sound on a sound channel.
Please note that sounds played with ‘Play One Shot’ can’t be stopped.
Change Playback Position
Changes the playback position of the currently playing music clip or an audio clip on a sound channel or game object’s audio source.
Audio Source Settings
Changes the settings of a music channel’s, sound channel’s or game object’s audio source component.
Change Sound Volume
Changes the sound volume – either sets or fades the volume. Already playing audio clips will not be updated by this.
Change Global Volume
Changes the global volume – either sets or fades the volume.
The global volume is used to scale both music and sound volume. Already playing audio clips will not be updated by this.
Audio/Audio Filter
Audio Chorus Filter
Changes settings of an audio chorus lter component on a game object.
If the component isn’t added, a new component will be added (requires an audio source or audio listener attached to the game object).
Audio Distortion Filter
Changes settings of an audio distortion lter component on a game object.
If the component isn’t added, a new component will be added (requires an audio source or audio listener attached to the game object).
Audio Echo Filter
Changes settings of an audio echo lter component on a game object.
If the component isn’t added, a new component will be added (requires an audio source or audio listener attached to the game object).
Audio High Pass Filter
Changes settings of an audio high pass lter component on a game object.
If the component isn’t added, a new component will be added (requires an audio source or audio listener attached to the game object).
Audio Low Pass Filter
Changes settings of an audio low pass lter component on a game object.
If the component isn’t added, a new component will be added (requires an audio source or audio listener attached to the game object).
Audio Reverb Filter
Changes settings of an audio reverb lter component on a game object.
If the component isn’t added, a new component will be added (requires an audio source or audio listener attached to the game object).
Audio/Audio Mixer
Transition To Snapshots
Transitions an audio mixer to a weighted mixture of snapshots. The weight weill be ignored if only one snapshot is found/used.
Set Output Mixer Group
Set the output audio mixer group of an audio mixer.
Set Audio Source Output
Set the output of an audio source to a de ned audio mixer group.
Set Music Channel Output
Set the output of a music channel to a de ned audio mixer group.
Audio Mixer Change Float
Sets or resets the value of an exposed oat parameter of an audio mixer. If the parameter was set, ‘Success’ will be executed, otherwise ‘Failed’.
Audio Mixer Store Float
Stores the value of an exposed oat parameter of an audio mixer into a oat variable. If the parameter exists, ‘Success’ will be executed, otherwise ‘Failed’.
Audio/Music
Change Music
Plays or stops a music clip.
Store Music
Stores a music channel’s currently playing music clip and its time position.
Is Music Playing
Checks if a de ned music channel or any channel is currently playing music or a de ned music clip.
Base
Layer Gate
Connects two layers.
Empty
This is an empty node.
This node being empty can be the result of a custom node script not being found (e.g. removed from the project).
This node will remember the data previously stored in it in case the script is added to the project again at a later time.
Wait
Waits for a de ned time.
Random
Randomly executes a next node out of a list of de ned nodes.
Comment
Leave a comment in your schematic.
This node does nothing and is only for commentary purposes.
Chance
Which node will be executed next is decided by chance.
The chance is checked against a random number between two values (default 0 and 100, you can change this in the game settings).
The next node of the rst de ned value range, that includes the chance, will be executed. If no range contains the chance, ‘Failed’ will be executed.
Check Value
A value (e.g. result of a formula) will be checked with a de ned value. If the check is valid, ‘Success’ will be executed next, otherwise ‘Failed’.
Loop
Increases an int variable by one until it reaches a de ned maximum value.
Use this node to easily loop nodes for a number of times before continuing with the rest of the schematic.
If the loop nished (i.e. the int variable being max count or larger), ‘Finished’ will be executed next, otherwise ‘Loop’.
Function
Send Message
Uses Unity’s SendMessage or BroadcastMessage functionality to call a de ned function (method) with a de ned value in every component of a game object or any of it’s children (broadcast).
Call Function
Uses re ection to call a function in a component.
Check Function
Uses re ection to call a function in a component and check the return value. If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Change Fields
Uses re ection to change elds or properties of a component.
Check Fields
Uses re ection to check the value of elds or properties of a component. If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Change Time Scale
Changes the time scale.
The time scale in uences the speed of everything in the game – you can use this to create slow motion e ects.
Call Plugin
Calls the ‘Call’ function of a selected plugin.
If the plugin was called successfully, ‘Success’ will be executed, otherwise ‘Failed’.
Game Object/Camera
Change Camera Position
Sets or fades the camera position, rotation and eld of view.
If all spawned instances of a prefab are used, the rst prefab will be used to change the camera.
Stop Camera Position Fade
Stops a currently fading camera position change.
Set Schematic Camera
Sets the camera used by the schematic (‘Camera’ object selection).
Store Initial Camera Position
Stores the camera’s current position, rotation and eld of view as initial camera position of the schematic.
You can use the ‘Initial Camera Position’ to reset or fade the camera to the stored position.
Initial Camera Position
Resets or fades the camera to the position, rotation and eld of view it had when ‘Store Initial Camera Position’ was used in this schematic.
This node will unmount the camera from it’s parent object.
Shake Camera
Shakes the camera.
Rotate Camera Around
Rotates the camera around a game object.
Orthographic Camera
Sets the camera to be orthographic or perspective.
Is Camera Orthographic
If the camera is orthographic, ‘Orthographic’ is executed, otherwise ‘Perspective’.
Mount Camera
Mounts or unmounts the camera to a game object.
Change Camera Options
Change various settings on a camera, e.g. culling mask, depth, etc.
Camera Target Texture
Set the ‘RenderTexture’ used as target for a camera – the camera will render into the de ned texture.
You must select a ‘RenderTexture’ asset.
Select no texture to remove the target texture and render to the screen again.
Collision Camera
Enable or disable the collision camera – can only be used when a ‘Collision Camera’ component is attached to the camera.
Game Object/Collider
In Collider Bounds
Checks if a collider’s bounds contain a game object’s position or a Vector3 value.
If the position/value is within a collider’s bounds, ‘Success’ will be executed, otherwise ‘Failed’.
Store Collider Bounds
Stores a value of the collider’s bounds into a Vector3 variable.
Store Squared Distance
Stores the smallest squared distance between a collider’s bounds and a position (Vector3) into a oat variable.
Collider Expand
Expands a collider’s bounds by increasing it’s size.
Changes bounds.size and doesn’t use the bounds.Expand function.
Collider Intersect Ray
Checks if a collider’s bounds intersect a ray (line).
If the bounds intersect the line, ‘Success’ will be executed, otherwise ‘Failed’.
Collider Intersect Bounds
Checks if a collider’s bounds intersect another collider’s bounds.
If the bounds intersect other bounds, ‘Success’ will be executed, otherwise ‘Failed’.
Collider Change Trigger
Changes if a collider’s is a trigger or not.
Collider Check Trigger
Checks if a collider is a trigger.
If the collider is a trigger, ‘Success’ will be executed, otherwise ‘Failed’.
Ignore Collision
Enables or disables ignoring collision between two colliders.
If collisions are ignored, collision and trigger events won’t be received between the used
colliders.
Please note that the ignore collision state isn’t persistant and can be lost, e.g. when deactivating the game object or collider, or adding a rigidbody component.
Ignore Layer Collision
Enables or disables ignoring collision between colliders on two layers.
If collisions are ignored, collision and trigger events won’t be received between all a ected colliders.
Check Ignore Layer Collision
Checks if collisions between two layers are ignored.
If collisions are ignored, ‘Ignored’ will be executed, otherwise ‘Not Ignored’.
Game Object/Component
Add Component
Adds a de ned component to a game object.
Remove Component
Removes a de ned component from a game object.
Enable Component
Enables or disables a de ned component from a game object.
Is Component Enabled
Checks if a de ned component of a game object is enabled.
If the component is enabled, ‘Success’ will be executed, otherwise (or if not found) ‘Failed’.
Emit Particles
Start or stop emitting particles on a game object.
For particles to start/stop emitting, the game object requires a ‘ParticleSystem’ or ‘VisualE ect’ component.
Change Scene Object
Changes the scene object used by a ‘Scene Object Component’.
Game Object/Constraint
Activate Constraint
Activates or deactivates de ned constraint components.
Is Constraint Active
Checks if de ned constraint components are active.
If the component is active, ‘Success’ will be executed, otherwise (or if not found) ‘Failed’.
Lock Constraint
Locks or unlocks de ned constraint components.
Is Constraint Locked
Checks if de ned constraint components are locked.
If the component is locked, ‘Success’ will be executed, otherwise (or if not found) ‘Failed’.
Set Constraint Weight
Sets the weight of de ned constraint components.
Check Constraint Weight
Checks the weight of de ned constraint components.
If the check is valid, ‘Success’ will be executed, otherwise (or if not found) ‘Failed’.
Add Constraint Source
Adds a transform source to de ned constraint components.
Remove Constraint Source
Removes a transform source from de ned constraint components.
Game Object/Game Object
Activate Object
Sets a game object active (enabled) or inactive (disabled).
Is Object Active
Checks if a game object is active (enabled) or inactive (disabled). If the object is active, ‘Active’ will be executed, otherwise ‘Inactive’.
Mount Object
Mounts or unmounts a game object to another game object. This will set the parent of the game object’s transform.
Don’t Destroy On Load
Marks an object to not be destroyed when loading a new scene. Calls ‘DontDestroyOnLoad’ using a selected object.
Destroy Object
Destroys a game object.
When destroying the machine’s game object, the machine might be stopped (due to it’s settings).
Please note that game objects are not destroyed immediately and will be destroyed by Unity at the end of the frame. Use the ‘Continue Next Frame’ option (or ‘Destroy After Time’) to continue with the schematic after the game object has been destroyed by Unity.
Object Exists
Checks if a game object exists.
If the object exists, ‘Success’ will be executed, otherwise ‘Failed’.
Is Object
Checks if 2 game objects are the same.
If the objects are the same, ‘Success’ will be executed, otherwise ‘Failed’.
Set Object Name
Sets an object’s name or tag.
Check Object Name
Checks an object’s name or tag.
If check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Set Object Layer
Sets an object’s layer.
Check Object Layer
Checks an object’s layer.
If check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Search Objects
Searches for game objects in the scene and uses them to change selected data.
Selected data can be used to store di erent data, e.g. a game object or a list of game objects.
Create Empty Object
Creates an empty game object.
Change Radius
Changes the radius of a game object.
Adds a ‘Radius’ component if none is added yet.
The radius is e.g. used when using ‘Move To Interaction’ to determine the movement destination.
Check Object Hierarchy
Checks if a game object has a parent or child object (or both).
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Object Visible
Sets a game object visible or invisible.
This is done by setting every Renderer and Projector component of the game object (and all of it’s children) active or inactive.
Object Blink Visible
Blinks a game object visible and invisible a de ned amount of times.
This is done by setting every Renderer and Projector component of the game object (and all of it’s children) active or inactive.
Is Visible
Checks if a game object’s renderer is visible by any camera.
If the object is visible, ‘Visible’ will be executed, otherwise ‘Not Visible’.
Game Object/Grid
Create Grid
Creates a game object grid.
Change Grid Size
Changes the size of a grid and optionally destroys game objects of removed grid cells.
Remove Grid
Removes a grid and optionally destroys all game objects of the grid cells.
Remove Grid Cell
Removes the game objects of grid cells and optionally destroys them.
Grid Exists
Checks if a game object grid exists for a de ned key.
If the grid exists, ‘Success’ will be executed, otherwise ‘Failed’.
Fill Grid Cells
Fills grid cells with prefab instances.
Set Grid Cell
Assigns game objects to grid cells.
Swap Grid Cell
Swaps game objects assigned to grid cells between 2 de ned grids.
If the de ned cells of one grid exceed the other in number, the smaller number of cells will be swapped.
You can also swap cells within the same grid by using the same grid twice.
Move Grid Cell
Moves game objects of grid cells within the grid.
E.g. move game objects down by one index on the Y axis.
Can Move Grid Cell
Checks if game objects of grid cells can be moved within the grid.
If the game objects can be moved, ‘Success’ will be executed, otherwise ‘Failed’.
Block Grid Cells
Blocks or unblocks cells of a grid.
Blocked grid cells can’t be changed (e.g. set to a di erent game object).
Is Grid Cell Blocked
Checks if a grid cell is blocked.
If the cell is blocked, ‘Blocked’ will be executed, otherwise ‘Not Blocked’.
Hide Grid Cells
Hides or unhides cells of a grid.
Game objects of hidden grid cells are disabled.
Is Grid Cell Hidden
Checks if a grid cell is hidden.
If the cell is hidden, ‘Hidden’ will be executed, otherwise ‘Not Hidden’.
Is Grid Cell Empty
Checks if a grid cell is empty (i.e. no game object is assigned to the cell). If the cell is empty, ‘Empty’ will be executed, otherwise ‘Not Empty’.
Is Grid Cell Object
Checks if game objects are part of a grid.
If the game objects are part of the grid, ‘Success’ will be executed, otherwise ‘Failed’.
Game Object/Light
Change Light Float
Changes or fades a oat value of a light, e.g. intensity or spot angle.
Light Culling Mask
Changes the culling mask of a light.
Change Light Mode
Changes the mode of a light.
You can change the light type, lightmapping mode, render mode, shadow resolution and shadows.
Change Light Cookie
Changes the cookie texture of a light.
Game Object/Prefab
Spawn Prefab
Spawns a prefab.
Destroy Prefab
Destroy prefabs.
Clear Spawned Prefabs
Removes references to spawned instances of a prefab.
The game object(s) will no longer be accessible through the ‘Spawned Prefab ID’.
Remove From Prefab Saver
Remove a game object from being saved by prefab savers.
If the game object was spawned and added to a prefab saver, this’ll prevent the game object’s data from being saved when changing scenes or saving the game.
Clear Prefab Savers
Remove stored data from prefab savers.
Game Object/Raycast
Raycast
Fires a raycast into the scene, optionally uses the hit object or stores hit values into variables. If something was hit, ‘Success’ will be executed, otherwise ‘Failed’.
Shapecast
Casts a shape into the scene, optionally uses the hit object or stores hit values into variables. If something was hit, ‘Success’ will be executed, otherwise ‘Failed’.
Capsule and sphere shapes will use ‘Collider’ components. Box and circle shapes will use ‘Collider2D’.
Check Shape
Checks if any colliders overlap a shape.
The overlapped game objects can also be used as the selected object, or change selected data (except when using a capsule shape).
If a collider overlaps the shape, ‘Success’ will be executed, otherwise ‘Failed’.
Capsule and sphere shapes use ‘Collider’ components. Area, circle and point shapes use ‘Collider2D’.
Game Object/Renderer
Change Sorting Layer
Changes a renderer’s sorting layer ID, name or order.
Change Material
Changes a renderer’s material or indexed material.
Material Color
Changes the color of a renderer’s material or indexed material.
If the renderer is a SpriteRenderer, the renderer’s color will be changed instead.
Material Texture
Changes a texture of a renderer’s material or indexed material.
Material Texture O set
Changes a texture o set of a renderer’s material or indexed material.
Material Texture Scale
Changes a texture scale of a renderer’s material or indexed material.
Material Texture Fork
Checks the texture of a renderer’s material.
If a texture matches, it’s next node will be executed. If no texture matches, ‘Failed’ will be executed.
Change Sprite
Changes a SpriteRenderer’s sprite.
Game Object/Rigidbody
Rigidbody Move Position
Moves a rigidbody to a position using Rigidbody.MovePosition.
Rigidbody Move Rotation
Rotates a rigidbody using Rigidbody.MoveRotation.
Rigidbody Add Force
Adds a force to a rigidbody.
Rigidbody Add Torque
Adds a torque to a rigidbody.
Rigidbody Position Force
Adds a force at a position and applies force and torque to a rigidbody.
Rigidbody Explosion Force
Adds exposion force to a rigidbody.
Rigidbody Stop
Stops adding continued forces or torques to a rigidbody.
Rigidbody Kinematic
Enables or disables the ‘Is Kinematic’ setting of a ‘Rigidbody’ (or ‘Rigidbody2D’).
Rigidbody Change Velocity
Changes the velocity of a ‘Rigidbody’ (or ‘Rigidbody2D’).
Rigidbody Store Velocity
Stores the velocity of a ‘Rigidbody’ (or ‘Rigidbody2D’) into a Vector3 variable. If no rigidbody is found, stores a zero Vector (0, 0, 0) into the variable.
Rigidbody Constraints
Changes the contraints of a ‘Rigidbody’ (or ‘Rigidbody2D’).
Rigidbody2D Body Type
Changes the physical behaviour type (body type) of a ‘Rigidbody2D’.
Game Object/Selected Object
Remove Selected Object
Removes the currently selected object (i.e. unselects it).
Set Selected Object
Selects a game object.
If the game object doesn’t have a ‘Selectable Object’ component attached, it will be attached automatically.
Select Nearest Object
Selects the nearest selectable game object.
Objects with a ‘Selectable Object’ component attached are selectable.
Select Left Object
Selects the next selectable game object to the left of another game object. Objects with a ‘Selectable Object’ component attached are selectable.
Select Right Object
Selects the next selectable game object to the right of another game object. Objects with a ‘Selectable Object’ component attached are selectable.
Is Selected Object
Checks if a game object is the currently selected object or if any game object is currently selected.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’
Game Object/Terrain
Is Terrain
Checks if a game object is a terrain.
If the check is valid, ‘Terrain’ will be executed next, otherwise ‘No Terrain’.
Is In Terrain Space
Checks if a position is within a terrain’s space.
The position can be de ned in world space, terrain space, alpha map and height map position. A position is within a terrain’s space if all axes are between 0 and 1 (converted to terrain space). If the check is valid, ‘Success’ will be executed next, otherwise ‘Failed’.
Transform Terrain Space
Transforms a position to or from terrain space and stores the result into a Vector3 variable. The position can be de ned and transformed to world space, terrain space, alpha map or height map position.
Change Terrain Height
Change the height of a terrain at a de ned position.
Change Terrain Alpha Map
Change the alpha value of a de ned texture index of a terrain at a de ned position.
Terrain Texture Fork
Checks the main texture at a position on a terrain. You must select a ‘Texture2D’ asset.
If a texture matches, it’s next node will be executed. If no texture matches, ‘Failed’ will be executed.
Game/Application
Quit Application
Quits the player application using ‘Application.Quit’. Warning: The game ends after this node.
Cancel Quit Application
Cancels quitting the player application by registering a method that returns false to ‘Application.wantsToQuit’.
It might already be too late to do this during the quitting process, try to use this node before that.
Capture Screenshot
Captures a screenshot as a PNG le.
Open URL
Opens an url in a browser.
Garbage Collection
Explicitly requests a garbage collection, calling System.GC.Collect().
Change Target Frame Rate
Changes the target frame rate of the application. Sets ‘Application.targetFramerate’ to do that.
Check Target Frame Rate
Checks the target frame rate of the application with a de ned value. If the check is valid, ‘Success’ will be executed next, otherwise ‘Failed’.
Game/Game
Start Game
Clears previous game data and starts the game, i.e. sets the game to ‘Running’.
Pause Game
Pauses or unpauses the game.
Stop Game
Clears previous game data and stops the game, i.e. sets the game to ‘Not Running’. Optionally shows the exit game question.
Is Game Running
Checks if the game is running.
If the game is running, ‘Success’ is executed, otherwise ‘Failed’.
Set Game Time
Set the game’s running time.
Check Game Time
Set the game’s running time.
If the check is valid, ‘Success’ is executed, otherwise ‘Failed’.
Change Game State
Activates or inactivates a game state.
Check Game State
Checks if game states are active or inactive.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Change Language
Changes the game’s language.
Check Language
Checks the game’s language.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Unload Unused Assets
Unloads assets that are not used.
Game/Player
Spawn Player
Spawns the player.
Destroy Player
Destroys the player’s game object.
Set Player
Sets a game object to be the new player.
Is Player
Checks if a selected game object is the player.
If the game object is the player, ‘Success’ is executed, otherwise ‘Failed’.
Game/Save Game
Save Game Menu
Calls the save, load or save point menu.
The schematic continues after the menu is closed, unless a save game has been loaded.
Auto Save
Saves the game to the AUTO save slot or creates a temporary retry save game.
Auto Save Slot Dialogue
Displays a dialogue to select the auto save slot.
Auto Load
Loads the game from the AUTO save game le or a temporary retry save game. The schematic ends after this step.
Save Game Exists
Checks if a de ned save game exists.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Can Continue
Checks if the continue save game is available.
The continue save game is either the retry save game or the last saved game. If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Continue
Loads the continue save game.
The continue save game is either the retry save game or the last saved game.
The schematic will end if the continue save game has been loaded, otherwise, the schematic will continue with the ‘Next’ slot.
Delete Auto Save
Deletes the AUTO save slot’s save game or the temporary retry save game.
Delete Save Game
Deletes a de ned save game or AUTO save game.
Check Auto Save Slot
Checks the currently used auto save slot’s index/number.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Game/Scene
Load Scene
Changes the scene and spawns the player, like using a ‘Scene Changer’ component. The scene needs to be added to the build settings of your project (read the Unity documentation for details).
Can Load Scene
Checks if a streamed level can be loaded.
If the level can be loaded, ‘Success’ will be executed, otherwise ‘Failed’.
Store Scene
Stores the current scene and player position/rotation. The stored scene can be used in load scene nodes.
Is Scene Stored
Checks if a scene is currently stored.
If a scene is stored, ‘Success’ is executed, otherwise ‘Failed’.
Set Scene Position
Set the default player position/rotation in a scene.
The scene positions can be used in load scene nodes and scene changers.
Is Scene Position Stored
Checks if a scene position for a scene is currently stored.
If a scene is stored, ‘Success’ is executed, otherwise ‘Failed’.
Check Scene
Checks the current scene’s name or index.
If the check is valid, ‘Success’ is executed, otherwise ‘Failed’.
Unload Scene
Unloads all game objects associated with a de ned scene name.
Use Scene Changer
Starts a scene changer on game object.
Clear Game Object Savers
Remove stored data from ‘Game Object Saver’ components.
Input
Input Key
Checks one or more input keys.
If an input key is pressed, it’s next node will be executed.
If no input key is pressed, ‘Failed: No Input’ will be executed.
Wait For Input
Waits for an input key (out of multiple keys) to be pressed, either for a set amount of time, or until the key has been pressed.
The next node of the input key that’s pressed rst will be executed.
If waiting for time and no key was pressed in time, ‘Failed: No Input’ will be executed.
Block Input Key
Blocks or unblocks an input key.
A blocked input key won’t receive any input.
Is Input Key Blocked
Checks if an input key is blocked.
If the input key is blocked, ‘Success’ is executed, otherwise ‘Failed’.
Set Input Key
Set the axis of an input key.
Reset Input Axes
Resets all input or only of a de ned input key.
All axes and buttons return to 0 (i.e. no input) for one frame.
Mouse Touch Delta
Stores mouse or touch movement delta into a Vector3 variable.
Mouse Touch Position
Stores the mouse or touch position into a Vector3 variable. The position will be calculated in the ‘Default Screen Size’, i.e.: Upper left corner: X=0, Y=0
Upper right corner: X=default screen width, Y=0
Lower left corner: X=0, Y=default screen height
Lower right corner: X=default screen width, Y=default screen height
Gyroscope Enable
Enables or disables the gyroscope of the device.
Gyroscope Interval
Changes the gyroscope’s update interval of the device.
Block Player Control
Blocks or unblocks the player control.
For each block, the block counter will increase by 1, for each unblock, the counter will decrease by 1.
As long as the counter is above 0 the player control will remain blocked.
Block Camera Control
Blocks or unblocks the camera control.
For each block, the block counter will increase by 1, for each unblock, the counter will decrease by 1.
As long as the counter is above 0 the camera control will remain blocked.
Control Component
Adds or removes a de ned component to or from the player or camera control list. While added, the component will be enabled/disabled with the controls.
A component can only be added once to the player or camera control list.
Change Cursor State
Changes the lock state of the cursor.
Check Cursor State
Checks the lock state of the cursor.
If the cursor is in the selected state, ‘Success’ will be executed, otherwise ‘Failed’.
Change Cursor Visible
Changes the visible state of the cursor.
Is Cursor Visible
Checks the visible state of the cursor.
If the cursor is visible, ‘Visible’ will be executed, otherwise ‘Hidden’.
Change Cursor Texture
Changes the texture of the cursor.
Change Input ID
Changes the global input ID or the schematic’s input ID. Use this to e.g. switch to a di erent control style.
Check Input ID
Checks the global input ID or the schematic’s input ID.
If the check is true, ‘Success’ will be executed next, otherwise ‘Failed’.
Directional Joystick Input
Stores horizontal and vertical values (e.g. input key axes) transformed by the direction of a game object (e.g. a camera) into a Vector3 variable.
E.g. use this for joystick input based on the camera direction.
Restore Control
Restores game control and removes all control blocks.
Machine
Restart Schematic
Restarts the schematic from the rst node in the next update tick.
Is Schematic Stopped
Checks if the schematic has been stopped, e.g. due to the machine object being destroyed. If the schematic has been stopped, ‘Stopped’ is executed, otherwise ‘Running’.
Check Start Conditions
Checks the start conditions (e.g. game state conditions, variable conditions) of the machine that started the schematic.
If the schematic wasn’t started by a machine, the check will be valid. If the check is valid, ‘Success’ is executed, otherwise ‘Failed’.
Find Actor Objects
Searches for actor game objects again.
Only actors that have ‘Find Object’ enabled will be searched again.
Start Machine
Starts a machine with a de ned schematic and uses game objects of this schematic as machine object and starting object.
The machine will be executed for each combination of machine object and starting object. E.g. 1 machine object and 3 starting objects result in 3 started machines.
Optionally, the machine can start without any machine/starting objects.
Start Tagged Machine
Starts ‘Tagged Machine’ components added to a game object.
All tagged machines with valid variable conditions that match the de ned tags will be started. This schematic will continue while the tagged machines are executed.
Start Global Machine
Calls a global machine.
The event will continue after the global machine has nished.
If the global machine can’t be executed (e.g. event le not found), the next node will be executed immediately.
Stop Global Machine
Stops a global machine.
The global machine is only stopped if it’s currently running and not using the ‘Multi’ execution type.
Add Machine Component
Adds a machine component to a game object.
Remove Machine Component
Removes a machine component from a game object.
Has Tagged Machine
Checks if a game object has a tagged machine with de ned tags.
If the game object has the de ned tagged machine, ‘Success’ will be executed, otherwise ‘Failed’.
Stop Machine Component
Stops machine components on a game object.
Stop Tagged Machine
Stops ‘Tagged Machine’ components added to a game object. All tagged machines matching the de ned tags will be stopped.
Search Tagged Machines
Searches for game objects with ‘Tagged Machine’ components (using de ned tags) in the scene and uses them to change selected data.
Selected data can be used to store di erent data, e.g. a game object or a list of game objects.
Machine/Machine Stack
Start Machine Stack
Starts a machine stack.
The machine stack will execute the machines on the stack in the order they’re added.
Stop Machine Stack
Stops a machine stack (i.e. no further machine will start).
The stack’s currently running machine can optionally be stopped.
If another schematic is waiting for the stack to nish, it’ll be noti ed after the stack’s running machine nished.
Remove Machine Stack
Removes a machine stack.
If the stack is currently executing, the stack will be stopped, also stopping the currently running machine.
If another schematic is waiting for the stack to nish, it’ll be noti ed after the stack’s running machine nished.
Clear Machine Stack
Removes all machines added to a machine stack.
An already running machine will not be stopped by this.
Reverse Machine Stack
Reverse the order of machines in a machine stack.
Shu e Machine Stack
Randomly sorts the machines in a machine stack.
Add Machine To Stack
Adds a machine to a machine stack.
Remove From Stack
Removes a machine from a machine stack.
The machine is identi ed through it’s index on the machine stack.
Remove Schematic From Stack
Removes a machine from a machine stack.
The machine is identi ed through the used schematic asset, i.e. the machine(s) using the de ned schematic asset will be removed from the stack.
Remove Object From Stack
Removes a machine from a machine stack.
The machine is identi ed through the machine object or starting object, i.e. the machine(s) using the de ned game object will be removed from the stack.
Is Machine Stack Running
Checks if a machine stack is currently running.
If the machine stack is running, ‘Success’ will be executed, otherwise ‘Failed’.
Machine Stack Exists
Checks if a machine stack exists.
If the machine stack exists, ‘Success’ will be executed, otherwise ‘Failed’.
Machine Stack Count
Checks the number of machines in a machine stack.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Stack Contains Schematic
Checks if a schematic asset is used in a machine stack.
If the machine stack contains the schematic, ‘Success’ will be executed, otherwise ‘Failed’.
Stack Contains Object
Checks if a game object is used as machine/starting object in a machine stack.
If the machine stack contains the game object, ‘Success’ will be executed, otherwise ‘Failed’.
Movement/Movement
Move
Moves a game object – use this node for ‘Update’ type machines/schematics.
This node will only move the game object a tiny distance and needs to be called repeatedly, e.g. in a ‘Tick’ machine.
Change Position
Sets or moves a game object to a new position.
Move Into Direction
Moves a game object into a de ned direction.
Curve Move
Moves a game object using curves.
The curve values are added to the game object’s original position at the start of the node. Only the axes that are enabled will be in uenced by the curve move.
Stop Movement
Stops movement from ‘Change Position’, ‘Move Into Direction’ and ‘Curve Move’ nodes.
Change Scale
Sets or fades the scale of a game object.
Check Distance
The distance between two objects is checked against a value. If the check is valid, ‘Success’ is executed, otherwise ‘Failed’.
Check Height Di erences
Checks if a game object is above or below another game object. If the check is valid, ‘Success’ is executed, otherwise ‘Failed’.
Check Transform
An object’s position, rotation or scale is checked against a value. Each axis (X, Y, Z) can be checked individually.
Can also use the change since the last frame as value.
If the check is valid, ‘Success’ is executed, otherwise ‘Failed’.
Change Gravity
Changes Physics.gravity or Physics2D.gravity.
The gravity in uences all game objects with a ‘Rigidbody’ or ‘Rigidbody2D’ component.
Check Speed
The horizontal or vertical movement speed of an object is checked against a value.
Uses ‘Object Changes’ components on the game object (added in ‘Auto’ mode if not already available) to get the current speed.
If the check is valid, ‘Success’ is executed, otherwise ‘Failed’.
Store Speed
Store the horizontal or vertical movement speed of an object into a oat variable.
Uses ‘Object Changes’ components on the game object (added in ‘Auto’ mode if not already available) to get the current speed.
Check On Ground
Checks if a game object is on the ground – uses either a ‘CharacterController’ component or a raycast.
If the check is valid, ‘On Ground’ is executed, otherwise ‘In Air’.
Smooth Follow
Moves a game object to follow another game object. Use this node for ‘Update’ type machines/schematics.
This node will only move the game object a tiny distance and needs to be called repeatedly, e.g. in a ‘Tick’ machine.
Clamp Transform
Clamps the axes of a game object’s position, rotation, scale, veloctiy or a direction (e.g. up, left, etc.) between two values.
Shake Object
Shakes a game object.
Store Predicted Position
Store the future position of a position (e.g. from a game object) based on a de ned velocity into a Vector3 variable.
Change Last Move Direction
Changes the last move direction value of ‘Object Changes’ components. This value can e.g. be used to determine the direction in 2D environments.
Please note that the last move direction will automatically be updated by the component the next time the game object moves.
Movement/NavMesh
NavMesh Destination
Sets the destination of a NavMesh agent or stop the agent.
NavMesh Value
Changes an int or oat value of a NavMesh agent.
E.g. speed, angular speed, acceleration, etc.
NavMesh Enable Agent
Enables or disables NavMesh agents.
NavMesh Stop Agent
Stops NavMesh agents.
NavMesh Set Path
Sets the path to a target position of a NavMesh agent.
Obstacle Avoidance
Changes the obstacle avoidance type of a NavMesh agents.
NavMesh Path Status
Checks the status of the current path of a NavMesh agents.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Activate O MeshLink
Activates or deactivates the current O MeshLink of a NavMesh agent.
Complete O MeshLink
Completes the current O MeshLink of a NavMesh agent.
Is On O MeshLink
Checks if a NavMesh agent is currently positioned on an O MeshLink.
If the agent is on an O MeshLink, ‘Success’ will be executed, otherwise ‘Failed’.
Is On NavMesh
Checks if a NavMesh agent is currently bound to a NavMesh.
If the agent is bound to a NavMesh, ‘Success’ will be executed, otherwise ‘Failed’.
NavMesh Reset Path
Resets the path of a NavMesh agent.
NavMesh Resume
Resumes movement along the current path of a NavMesh agent.
NavMesh Warp
Warps a NavMesh agent to the de ned position.
If it was successful, ‘Success’ will be executed, otherwise ‘Failed’.
Store Closest Edge
Stores the closest NavhMesh edge into a Vector3 variable.
If an edge was found, ‘Success’ will be executed, otherwise ‘Failed’.
Store Nav Raycast
Casts a NavMesh raycast between an agent and a target position and stores the hit obstacle position into a Vector3 variable.
If an obstacle was found, ‘Success’ will be executed, otherwise ‘Failed’.
Store Area Cost
Stores the cost for path calculation when crossing area of a particular type into a oat variable.
NavMesh Area Cost
Changes the cost for traversing over areas of a particular type for a NavMesh agent.
NavMesh Remaining Distance
Checks the remaining distance to the destination of a NavMesh agent. If the check was valid, ‘Success’ will be executed, otherwise ‘Failed’.
Store Sample Position
Stores the closest position on a NavMesh within a de ned range of a source position into a Vector3 variable.
If a point was found, ‘Success’ will be executed, otherwise ‘Failed’.
Movement/Rotation
Rotate
Rotates a game object – use this node for ‘Update’ type machines/schematics.
This node will only move the game object a tiny distance and needs to be called repeatedly, e.g. in a ‘Tick’ machine.
Rotate Around
Rotates a game object around a position or another object – use this node for ‘Update’ type machines/schematics.
This node will only move the game object a tiny distance and needs to be called repeatedly, e.g. in a ‘Tick’ machine.
Change Rotation
Sets or fades the rotation of a game object.
Rotate To
Rotates a game object toward a position, a game object or the mouse position.
Curve Rotation
Rotates a game object using curves.
The curve values are added to the game object’s original rotation at the start of the node.
Check Angle
The angle between two objects is checked against a value. If the check is valid, ‘Success’ is executed, otherwise ‘Failed’.
Store Angle
Stores the angle between two objects into a oat variable.
Store Position Angle
Stores the angle from a game object to a position into a oat variable.
Check Orientation
Checks the orientation from objects to other objects (e.g. if an object is in front of another object).
If the check is valid, ‘Success’ is executed, otherwise ‘Failed’.
Orientation Fork
Checks the orientation from objects to other objects (e.g. if an object is in front of another object).
The next slot of the according orientation will be executed next, e.g. if an object is in front of
another object, the ‘Front’ slot will be executed next.
If no orientation can be determined (e.g. one or both objects are not found), the ‘None’ slot will be executed next.
Movement/Waypoint Path
Follow Path
Makes a game object follow the path of a ‘Waypoint Path’ component.
Pause Path
Pauses or resumes a game object following the path of a ‘Waypoint Path’ component.
Reverse Path Move
Reverses a game object’s move direction while following the path of a ‘Waypoint Path’ component.
E.g.: If the game object currently moves from lowest to highest path point index, it will reverse direction and move from highest to lowest path point index.
Store Nearest Path Point
Stores the nearest position of a path to a selected game object into a Vector3 variable.
Networking/Web Request
WebRequest Call
Does a UnityWebRequest call with a de ned URL.
If the call is a success, ‘Success’ will be executed, otherwise ‘Failed’.
Store WebRequest Text
Stores the result of a UnityWebRequest call into a string variable. If the call is a success, ‘Success’ will be executed, otherwise ‘Failed’.
Store WebRequest Texture
Stores a texture downloaded by a UnityWebRequest call into a de ned texture of the schematic.
If the call is a success, ‘Success’ will be executed, otherwise ‘Failed’.
UI
Is UI Box Focused
Checks if a UI box stored in selected data is focused.
If the UI box is focused, ‘Success’ will be executed, otherwise (or if no UI box found) ‘Failed’.
UI/Dialogue
Close All Dialogues
Closes all dialogues opened by this schematic.
Only dialogues from ‘Show Dialogue’ nodes are closed.
Show Dialogue
Displays a dialogue or choice dialogue.
The schematic continues when the dialogue or choice is accepted with the accept key. Choices are selected with the horizontal and vertical key or with a click/touch.
Choice dialogues can have as many choices as you like, every choice has it’s own next node setting which will execute the next node based on the selected choice.
If you select ‘Choice’, the ‘Next’ setting is only used if no choices are available.
Value Option Dialogue
Displays a dialogue to change game options or input values and store them in variables. The schematic continues when the dialogue is accepted or canceled.
Language Dialogue
Displays a language selection dialogue and changes the game’s language to the selected language.
The schematic continues when the dialogue is accepted with the accept key (or canceled).
Show Flying Text
Displays a ying text noti cation at the position of an object.
Block Flying Texts
Blocks or unblocks new ying texts from being displayed.
Are Flying Texts Blocked
Checks if ying texts are blocked.
If ying texts are blocked, ‘Blocked’ will be executed next, otherwise ‘Unblocked’.
Unity Console
Prints a text to the Unity console using ‘Debug.Log()’.
Pause Noti cations
Pauses or resumes displaying noti cations.
Paused noti cations will not be displayed and their visible time doesn’t progress.
Block Noti cations
Blocks or unblocks adding new noti cations.
Are Noti cations Blocked
Checks if adding new noti cations is blocked.
If noti cations are blocked, ‘Blocked’ will be executed next, otherwise ‘Unblocked’.
Hide Autoclose Dialogues
Hides or shows (new) ‘Autoclose’ type dialogues.
Please note that this only hides the UI box of these dialogues, their wait time (or accepting them) is still used.
Are Autoclose Dialogues Hidden
Checks if ‘Autoclose’ type dialogues are hidden.
If they are hidden, ‘Hidden’ will be executed, otherwise ‘Shown’.
UI/HUD
Call HUD
Calls (shows) or closes a HUD.
A HUD can only be opened once at a time.
If an already shown HUD is called, it’s users will be updated according to this node’s settings (if the HUD supports users).
Is HUD User
Checks if a game object is used as a HUD’s user.
If the check is valid, ‘Success’is executed, otherwise ‘Failed’.
Toggle HUD
Toggles a list of de ned HUDs on or o .
If a HUD is toggled o , it won’t be displayed.
A HUD can also be toggled using input keys, if set up in the HUD’s settings.
Block HUD
Blocks or unblocks a HUD.
A blocked HUD won’t be displayed.
Navigation Marker
Adds or removes a navigation marker.
Navigation markers are displayed by navigation HUDs.
UI/Image
Show Image
Shows an image on the screen.
Images are displayed on a UI layer before the UI boxes of the layer.
You can access images later by referring to their ID – you can even access images created by other schematics.
Change Image Bounds
Changes the position and size of an image.
Images are displayed on a UI layer before the UI boxes of the layer.
You can access images later by referring to their ID – you can even access images created by other schematics.
Change Image Color
Changes the color of an image.
Images are displayed on a UI layer before the UI boxes of the layer.
You can access images later by referring to their ID – you can even access images created by other schematics.
Remove Image
Removes an image from the screen.
Images are displayed on a UI layer before the UI boxes of the layer.
You can access images later by referring to their ID – you can even access images created by other schematics.
UI/UI Components
UI Rect Transform
Changes settings of a ‘Rect Transform’ component.
UI Text
Changes settings of a ‘Text’ component.
UI Raw Image
Changes settings of a ‘Raw Image’ component.
UI Image
Changes settings of an ‘Image’ component.
UI Slider
Changes settings of a ‘Slider’ component.
UI Scrollbar
Changes settings of a ‘Scrollbar’ component.
UI Toggle
Changes settings of a ‘Toggle’ component.
UI Input Field
Changes settings of an ‘Input Field’ component.
Store UI Input Field
Stores the text value of an ‘Input Field’ component into a string variable.
Store UI Toggle
Stores the toggle value of a ‘Toggle’ component into a bool variable.
Store UI Slider
Stores the value of a ‘Slider’ component into a oat variable.
Store UI Scrollbar
Stores the value of a ‘Scrollbar’ component into a oat variable.
Store UI Anchored Position
Stores the anchored position (3D) of a ‘Rect Transform’ component into a Vector3 variable.
Store UI Size Delta
Stores the size delta of a ‘Rect Transform’ component into a Vector3 variable.
Value/Date and Time
Change Date and Time
Changes a date/time value (string) using a oat value to change a de ned part of the time (e.g. seconds, minutes or hours).
E.g. add 5 hours to a date/time value.
Check Date and Time
A date/time string will be checked with a de ned date/time string.
If the check is valid, ‘Success’ will be executed next, otherwise ‘Failed’.
Date and Time to Float
Stores a date/time value (string) as a oat variable.
Either store the whole value in seconds or only parts of it (e.g. seconds, hours or years).
Date and Time Di erence
Stores the di erence between 2 date/time values (string) in seconds as a oat variable.
Value/Float
Float Random
Stores a random number between two de ned numbers into a oat or int variable.
Float Atan2
Store the angle in radians whose Tan is Y/X into a oat variable.
Float Clamp
Clamps a oat value between a minimum and maximum and stores it into a oat variable.
Float Delta Angle
Calculates the shortest di erence between two angles and stores it into a oat variable.
Float Inverse Lerp
Calculates the Lerp parameter between two values and stores it into a oat variable.
Float Lerp
Interpolates between two values and stores it into a oat variable.
Float Move Towards
Moves a value current toward target and stores it into a oat variable.
Float Perlin Noise
Generates 2D perlin noise and stores it into a oat variable.
Float Ping Pong
PingPongs or loops (repeats) a value, so that it is never larger than length and never smaller than 0, and stores it into a oat variable.
Float Smooth Damp
Gradually changes a oat value towards a desired goal over time and stores it into a oat variable.
Float Smooth Step
Interpolates between two values with smoothing at the limits and stores it into a oat variable.
Float To Angle
Changes a oat value into an angle (i.e. between 0 and 360) and stores it into a oat variable.
E.g. -90 will become 270, 480 will become 120.
Float is Power of 2
Checks if an int value is power of two.
If check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Value/PlayerPrefs
Set String PlayerPrefs
Sets a string value to a PlayerPrefs variable.
Set Int PlayerPrefs
Sets an integer value to a PlayerPrefs variable.
Set Float PlayerPrefs
Sets a oat value to a PlayerPrefs variable.
Remove PlayerPrefs
Removes a PlayerPrefs variable.
Has PlayerPrefs
Checks if a PlayerPrefs variable exists.
If the check is true, ‘Success’ will be executed, otherwise ‘Failed’.
Value/Selected Data
Select HUD Content Provider
Use the content/user of a HUD content provider component attached to a game object to change selected data.
Select UI Input Context
Use the schematic context of a UI input component attached to a game object to change selected data.
E.g. get the schematic context added to a choice button.
Select UI Base Component
Use the ‘UI Box’ or ‘HUD’ component (or anything implementing ‘IUIBase’) attached to a game object to change selected data.
Clear Selected Data
Clears/removes selected data.
Either removes all data of a de ned data key, or removes all data.
Selected Data Count
Checks how many data is stored in a selected data list.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Select Selected Data
Uses the rst, last, a random or all content from another selected data as selected data.
E.g. select a random content from a list of data.
If something was stored, ‘Success’ will be executed, otherwise (i.e. nothing left to store) ‘Failed’.
Select Variable Handlers
Uses variable handlers to change selected data.
A variable handler stores all variables of an origin, e.g. the global variables or object variables of a game object.
Select Components
Uses components to change selected data.
Select Game Objects
Uses game objects to change selected data.
Select Nearest Game Object
Use the nearest game object to change selected data.
Filter Selected Game Objects
Filters game objects stored in selected data and only keeps game objects matching the de ned conditions.
Other data (e.g. components or variable handlers) will be removed.
Selected Game Objects Count
Checks how many game objects are stored in selected data.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Selected Game Objects Contain
Checks if a game object is stored in selected data.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Value/Text File
Read Text File
Reads a text le and stores it into string variables.
Read Text File Lines
Reads a text le and adds each line to a string variable list.
Write Text File
Writes into a text le.
Write Text File Lines
Writes a string variable list’s values into a text le (each value being a line).
Load CSV File
Loads a CSV le’s data for later use as bool, oat and string values.
Clear CSV File
Removes a CSV le’s loaded data or all CSV data.
Value/Timer
Start Timer
Starts a timer on a oat variable.
A timer will count the used oat variable up or down using the delta time each tick.
Stop Timer
Stops a timer on a oat variable.
Is Timer Running
Checks if a timer on a oat variable is running.
If the timer is running, ‘Success’ will be executed, otherwise ‘Failed’.
Pause Timer
Pauses or unpauses a timer on a oat variable.
Is Timer Paused
Checks if a timer on a oat variable is paused.
If the timer is paused, ‘Success’ will be executed, otherwise ‘Failed’.
Value/Variable
Store Function Result
Stores the return value of a function into a variable.
Supports string, bool, int/ oat and Vector2/Vector3 return values.
If a variable is changed, ‘Success’ will be executed, otherwise ‘Failed’.
Store Field
Stores the value of a eld or property into a variable. Supports string, bool, int/ oat and Vector2/Vector3 values.
If a variable is changed, ‘Success’ will be executed, otherwise ‘Failed’.
Change Variables
Changes variables.
Check Variables
Checks if variables have certain values.
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Variable Fork
Checks a single variable for certain values.
If a variable condition is valid, it’s next node will be executed. If no variable condition is valid, ‘Failed’ will be executed.
Clear Variables
Removes all variables and variable lists.
Variable Transfer
Transfers all variables and variable lists from one origin to another (local, global and object).
Variable Exists
Checks if a variable exists (i.e it has been set).
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.
Sort Variable List
Sorts a variable list.
Copy Variable List
Stores all values of a variable list in another variable list.
Variable List Contains
Checks if a variable list contains a de ned value.
If the variable list contains the value, ‘Success’ will be executed, otherwise ‘Failed’.
Store Variables
Stores the data from a de ned variable source into a le or PlayerPrefs variable (string). The data is stored as an XML-formatted string.
Load Variables
Loads the data stored in a le or PlayerPrefs variable (string) into a de ned variable source. The data is loaded from an XML-formatted string.
Please note that loading variables into a source will remove all current variables from the source.
Change Number Object Variables
Changes an int or oat variable on all currently registered object variables.
Only changes object variables using an ‘Object ID’, local object variables will not be changed.
Value/Vector
Vector3 Random
Stores a Vector3 with random X, Y and Z axes into a variable.
Vector3 Transform Value
Transforms a Vector3 value between local and world space of a game object and stores the result into a variable.
Vector3 Angle
Store the angle in degree between two Vector3 into a oat variable.
Vector3 Direction
Store the direction from one Vector3 (position) to another into a Vector3 variable.
Vector3 Magnitude
Store the magnitude (length) or square magnitude (squared length) of a Vector3 into a oat variable.
Vector3 Clamp
Store a Vector3 with it’s axes clamped between two values into a variable.
Vector3 Clamp Magnitude
Store a Vector3 with it’s magnitude clamped to a max length into a variable.
Vector3 Lerp
Store the linear or spherical interpolation between two Vector3 into a variable.
Vector3 Move Towards
Moves the Vector3 current in a straight line towards a target and stores it into a variable.
Vector3 Rotate Towards
Rotates the Vector3 current towards a target and stores it into a variable.
Vector3 Ortho Normalize
Makes two or three Vector3 variables normalized and orthogonal to each other.
Vector3 Multiply
Multiplies a Vector3 with a oat and stores it into a variable.
Vector3 Divide
Divides a Vector3 by a oat and stores it into a variable.
Vector3 Rotate
Rotates a Vector3 and stores it into a variable.
Vector3 Smooth Damp
Gradually changes a Vector3 value towards a desired goal over time and stores it into a variable.
Vector3 To Angle
Changes all axes of a Vector3 value into a angles (i.e. between 0 and 360) and stores it into a Vector3 variable.
E.g. -90 will become 270, 480 will become 120.
Vector3 Check Distance
The distance between two Vector3 values is checked against a value. If the check is valid, ‘Success’ is executed, otherwise ‘Failed’.
Updated on February 22, 2023
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Schematics
Schematics
Schematics are the core feature of Makinom – learn what you can do with them!
A schematic is a reusable, node-based blueprint for what you want to do. It consists of connected nodes that work similar to a ow chart – each node performs a task and decides the next node that’ll be executed. There are over 400 nodes available for di erent tasks, and you can add new nodes via scripting or call custom code and 3rd party functionality using function nodes.
Schematics are created in the Makinom editor in the Schematics section using the node editor.
So, what can you do with schematics? Pretty much everything, e.g.:
player controls camera controls animation handling animating a cut-scene
procedurally/randomly creating a level
various game mechanics, e.g. managing player health menus, dialogues, …
enemy AI and behaviours level handling
audio management
communication with 3rd party software and much more!
All of this is done by adding and connecting nodes, without writing a single line of code!
Playing Schematics
Schematics are played by machines and other schematics. Machines are components used to play schematics, you can learn more about them in their documentation.
Playing schematics by other schematics allows breaking down tasks into several schematics, making them reusable and shorten the time needed to create your game mechanics.
E.g. change the health of the player (or any other character in the game) and check for a death condition in a separate schematic allows reusing it wherever needed (like di erent attack schematics, for damaging and recovering health through items, etc.).
If something needs to be changed later, you only need to change it in this one schematic and not in all places where this game mechanic is used.
Settings
The schematic’s Settings node marks the start of a schematic – the node connected to it’s slot is the rst node that’ll be executed.
Enabling Use End Slots in the settings node will add 2 additional slots, one to execute nodes when stopping the schematic (e.g. from the machine being destroyed) and one upon ending the schematic regularly (e.g. when the schematic branches into multiple endings and all of them should do some cleanup at the end).
The Settings node also de nes the schematic’s main settings, e.g. actors and used resources (like prefabs, audio clips, etc.).
Machine Start Variables
De ne local variables that are exposed to the machine component using the schematic.
This can be used to quickly set local start variables and change their value in machine components.
Initial Local Variables
De ne local variables that will be set at the start of the schematic.
They’re not exposed to the machine component and will overrule start variables set by the machine component.
Actors
Actors are Game Objects that are already present in the scene. You’ll use actors in many nodes to perform a task, e.g. moving an actor to a position, playing a sound on an actor or change values on an actor’s component.
There are default objects are available without adding actors:
Machine Object
The game object the machine component is running on.
Starting Object
The game object that started the machine (e.g. the player).
Camera
The camera game object used by the schematic (by default the Main Camera).
Selected Data
Game objects stored in Selected Data.
This can optionally be limited to only use stored game objects – otherwise it’ll also use game objects from stored components, etc.
Depending on the Data Origin, the list is either only available in the running schematic (Local), everywhere (Global) or through a game object (Object, Object ID).
E.g. you can add game objects by nding them through their name or when they where hit by a raycast.
Learn more about selected data here.
Selected Object
The currently selected game object.
Game objects with a Selectable Object component attached can be selected, e.g. by clicking on them or pressing a de ned input key.
See Base/Controls > Game Controls > Object Selection for details and settings related to selected objects.
If you need additional game objects of the scene, add them as an actor to the schematic. Beside selecting the actor in the machine component, you can also let the schematic nd a game object or multiple game objects by name, tag or an attached component.
Actor Types
The following actor types are available.
Machine Object
The game object the machine component is running on.
Starting Object
The game object that started the machine (e.g. the player).
Player
The game object of the player.
Find Object
Searches for game objects in the scene based on name, tag, components or other lters.
Game Object
Allows selecting a game object in the machine component that uses the schematic.
Selected Data
Game objects stored in Selected Data.
This can optionally be limited to only use stored game objects – otherwise it’ll also use game objects from stored components, etc.
Depending on the Data Origin, the list is either only available in the running schematic (Local), everywhere (Global) or through a game object (Object, Object ID).
E.g. you can add game objects by nding them through their name or when they where hit by a raycast.
Learn more about selected data here.
Selected Object
The currently selected game object.
Game objects with a Selectable Object component attached can be selected, e.g. by clicking on them or pressing a de ned input key.
See Base/Controls > Game Controls > Object Selection for details and settings related to selected objects.
You can also create custom actor type implementations by deriving your class from the BaseActorType class. Check the available actor classes for examples.
Assets and Resources
Schematics can use di erent Unity assets, currently supported are:
Prefabs
E.g. to spawn prefabs in the scene.
Audio Clips
E.g. to play an audio clip on a game object.
Audio Mixers
E.g. to change an audio mixer’s values.
Audio Mixer Groups
E.g. to change the output audio mixer group of an Audio Source.
Sprites
E.g. to change the sprite of a game object.
Textures
E.g. to change the texture of a game object.
Materials
E.g. to change the material of a renderer.
Physic Materials
E.g. to change the physic material of a collider.
Physics Material 2Ds
E.g. to change the physics material 2D of a collider 2D.
While you can add those resources directly in the node you want to use them, you can use advanced functionality by adding them as resources to a schematic in the schematic’s settings (i.e. the start node). A single resource can use multiple assets that can be used in sequence, reversed sequence or randomly.
A single audio clip resource will be used as footstep sounds. Adding mutiple audio clips to the resource and using the Random use order will randomly play one of the added audio clips when used in a Play Sound node.
Resource overrides
By adding assets as resources to a schematic, you can override them in machine components. This further increases the reusability of schematics, as you can create more generic schematics that perform a task, but use di erent assets on di erent occasions.
Overriding the previous footstep audio clip resource in machine components allows having di erent random footsteps for di erent game objects, e.g. a small character having light footsteps while a big character stomps quite loudly.
Nodes
Each node represents a task that it’ll process, before executing the next node. As said, there are over 400 nodes available for various tasks, ranging from simple things (like spawning a prefab, playing an audio clip or increasing a counter) to complex operations (like movement over time, raycasting or showing a dialogue).
You can add nodes via the context menu (right/context click), learn more about using the node editor in this documentation.
You can see a list of all available nodes in this documentation.
Node Types
Schematic nodes are generally arranged into similar topics/categories.
Some nodes can also be available in multiple categories.
Animation
Animation nodes contain everything animation related, from legacy to Mecanim animations, but also include fading colors or the screen and using playables.
Audio
Audio nodes contain everything audio related, e.g. playing music and audio clips, but also include handling audio mixers and lters.
Base
Base nodes contain some basic functionality that’s not matching in any other categorie, e.g. the Wait node to wait for a certain amount of time, chance checks or debug output.
Check
Check nodes are a collection of all nodes that perform checks (and execute the next node depending on that), they mainly contain nodes from other categories.
Function
Function nodes are used to connect custom or 3rd party features by using re ection to call their functions or change/check elds and properties on their classes and components.
Game Object
Game object nodes contain a wide variety of everything game object and component related,
e.g. spawning prefabs, adding components, expanding colliders or manipulating terrains.
Game
Game nodes contain anything related to the overall game and application, e.g. quitting the application, changing game states or loading scenes, but also setting and spawning the player or handling save games.
Input
Input nodes contain anything input related, e.g. checking input keys, blocking player control or changing the cursor state.
Machine
Machine nodes contain anything schematic and machine related, e.g. starting schematics or tagged machines, using machine stacks or restarting the schematic.
Movement
Movement nodes contain anything movement related, e.g. moving or rotating game objects, using NavMesh or Makinom’s waypoint paths.
Networking
Networking nodes contain anything network related, which currently is limited to using Web Requests.
UI
UI nodes contain anything UI related, e.g. showing dialogues, calling HUDs, showing images or changing UI components.
Value
Value nodes contain anything value related, e.g. changing and checking variables, using
selected data, date and time functionality, timers, oat and Vector3 operations.
Custom Nodes
You can create custom nodes by deriving from the BaseSchematicNode
or BaseSchematicCheckNode classes. For examples it’s best to check out the available node implementations.
See the custom nodes documentation for details.
Importing Dialogues
You can import dialogues to create a series of Show Dialogue nodes using the dialogue importer.
Open the Dialogue Importer using the context menu in the schematic node editor: Open Dialogue Importer
Learn more about it in this documentation. Machines, Schematics
Share This Article :
Updated on February 22, 2023
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Scripting Scripting Overview
Scripting Overview
A brief overview on scripting with Makinom.
You can nd an overview of all available classes in the API documentation.
When scripting with Makinom, either add the GamingIsLove.Makinom namespace (using) or implement your class in the GamingIsLove.Makinom namespace.
1.
2.
3.
4.
5.
6.
7.
8.
// add Makinom namespace
// or use Makinom namespace
{
}
Please note that some of Makinom’s classes are in separate namespaces, e.g. GamingIsLove.Makinom.Components is used for all component classes of Makinom.
The Maki class
Most of what you need is accessible through the Maki class. It holds references to all data directly referenced by the project (e.g. input keys) and handlers for an easy and centralized access point.
Accessing settings and data
All individual data list entries are stored as separate assets, only some of them can be accessed through the Maki class due to being directly referenced by the project asset:
Maki.Languages Maki.GameStates Maki.InputKeys Maki.MusicClips Maki.GlobalMachines Maki.UILayers Maki.UILayouts Maki.UIBoxes Maki.HUDs Maki.Plugins
E.g. if you want to get an input key, you can access it like this:
1. InputKey inputKey = Maki.InputKeys.Get(index);
index is an int value representing the index of the input key in the Makinom editor’s list. You can also access them via their GUID (string):
1. InputKey inputKey = Maki.InputKeys.Get(guid);
guid is a string value representing the GUID of the data.
Beside data list entries, you can also access the general settings, e.g.:
Maki.GameControls Maki.GameSettings
Handlers
There are multiple handler classes that manage parts of a running game.
Instances of those handlers can be accessed via the Maki class during a running game – some examples:
Game Handler: Maki.Game
The Game Handler manages all in-game related data, e.g. the player, global variables,
factions, game time, language, etc.
Player Handler: Maki.Game.Player
The Player Handler holds the reference to the player’s game object and handles spawning the player’s prefab (if used).
The player’s game object can be accessed directly through Maki.Game.Player.GameObject.
Variable Handler: Maki.Game.Variables
This gives you access to the global variables.
The Variable Handler class is used for managing variables.
Save Games: Maki.SaveGame
The Save Game Handler manages saving and loading the game.
Data Assets
Data of things like input keys, music clips or formulas are all stored in individual assets.
They are like any regular Unity asset and can be referenced in your custom scripts and components, e.g. an input key:
1. public InputKeyAsset inputKey;
Settings
You can access the settings of an asset via the property, e.g. checking if an input key asset registered a button input for an inputID.
1. if(inputKey.Settings.GetButton(inputID))
The inputID in this case is an int value representing the input ID to check for (see the Input ID setting of input keys).
As mentioned above, only some of the data assets are directly referenced by the project asset and accessible via the central Maki class. This is due to initializint the project via a game starter also needs to load all references assets, leading to long load times if everything is directly referenced by the project.
Settings
All classes containing settings that are accessible and saved in the editor must be descendants of the IBaseData interface. The interface implements 2 functions, GetData and SetData, using
a DataObject class to store the information in it, and a 3rd function (EditorAutoSetup) used by some special editor cases.
It’s easiest to descend your class from the BaseData class, which already has a default implementation of the interface and handles saving/loading the data automatically.
Save Games
Save games work similar to the settings class – instead of the IBaseData interface, you need to implement the ISaveData interface.
You can nd an sample implementation in the custom save data documentation.
Custom Nodes
Adding custom nodes to schematics or formulas doesn’t require implementing them in a plugin or Makinom’s source code – you can just add them in a script le in your Unity project.
You can nd more details about custom node implementations in the custom nodes documentation.
Schematic Nodes
Schematic nodes must descend from BaseSchematicNode or any other schematic node class (e.g. BaseSchematicCheckNode for the default Success/Failed slot implementation).
Formula Nodes
Formula nodes must descend from BaseFormulaNode or any other formula node class (e.g. BaseFormulaCheckNode for the default Success/Failed slot implementation).
Code Extensions
You can extend many of Makinom’s type selections and settings with custom implementations by simply adding new scripts descending from a base type class.
Learn more in the code extension documentation.
Source Code Project
The full source code included in Makinom Pro is a Visual Studio 2017 project and should be ready to use out of the box.
The required references to Unity DLLs and functionality are already set up (the DLLs are included in the project’s bin/References folders). If you want to use di erent Unity versions than provided, just replace the references with the libraries you want to use.
Updated on June 23, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Selected Data
Selected Data
The Selected Data feature can be used for all kinds of custom systems. Selected Data is used to store di erent things for later use.
Selected data could be anything, e.g.:
a game object or multiple game objects a component or multiple components
a variable handler or multiple variable handlers (a variable handler stores all variables of an origin, e.g. global variables)
a combination of di erent things, e.g. a game object, a component and 2 variable handlers You can keep track of di erent selected data by using di erent Data Keys to identify them.
Like variables, selected data is available in di erent scopes – local (schematics, formulas),
global and bound to game objects (using an Object Variables component).
The data key hitObjects holds all game objects that where hit by a raycast, while the data key variables holds the global variables and object variables of 2 game objects.
Selected data isn’t saved in save games.
Data Origin
The origin of a selected datavariable de nes where it’s stored and how it can be accessed. There are 3 di erent data origins – when dealing with selected data (e.g. changing it, checking it or using it’s values), you’ll always need to select the origin.
Local
Local selected data is only available in a playing schematic or calculating formula. They’re best used for short lived information, like a game object hit by a raycast that is needed in the following nodes.
A crucial mechanic is sharing local variables between schematics and formulas that are started/used by each other – this allows passing on information and doing di erent things depending on where they’re started from.
Schematics
Local selected data in schematics is only available as long as the schematic is playing. The selected data is gone when the schematic nished playing.
Machines and schematics that are started by a schematic can share the local selected data, i.e. the newly started machine will have the same selected data as the one it was started by, and the schematic that started the machine will also get the changes that where made in the
new machine.
Furthermore, schematics share the local selected data with formulas that are used in the schematic.
Formulas
Local selected data in formulas is only available as long as the formula is calculating. The selected data is gone when the formula nished calculating.
Formulas that are used in other formulas will share the same local selected data. Also, formulas that are used in schematics will share the local selected data with the schematic. This can be used to e.g. initialize data for the formula’s calculation.
Examples
A Raycast node stores the hit game object in the local selected data hitObject.
The following Start Tagged Machine will start tagged machines on the game objects stored in hitObject.
Global
Global selected data is available everywhere and at any time – it’s persistent in the running game, i.e. it’ll be available in all machines/schematics, formulas and other parts of Makinom.
Since global selected data is persistent, you can use it to store information that needs to be remembered for longer periods of time, like marking game objects for other schematics.
Examples
Clicking (interaction machine) on game objects stores them in the global selected data marked.
Pressing an input key (interaction machine, tick machine) res rockets on all game objects stored in marked.
Object
Object selected data is bound to game objects in your scene by an Object ID. Like global selected data, it’s available everywhere and at any time.
Since object selected data is bound to objects, it’s mostly used for storing information that is in relation to an object, like the marked targets of an enemy.
Object Variables Component
Binding object selected data to a game object is done by adding an Object Variables component to the game object. When game objects share the same Object ID in their object variable components, they’ll share the same selected data.
Optionally, the component can be set to be used in a local mode by enabling Local Variables. When used as local variables, the object selected data is only available as long as the game object exists and can’t be shared between objects. This is usually used for storing information on not unique game objects, like enemies that are used multiple times.
Schematics and Formulas
Object selected data can be accessed in schematics and formulas in two ways:
Game Object
Uses an object variables component attached to the game object to get the selected data. If there is no component attached, the selected data can’t be used.
Object ID
Uses the object ID to get the selected data.
This doesn’t require a game object and allows using object selected data without binding them to an actual object.
Using an object ID to access the selected data makes it available whenever needed, without a game object. This mechanic can be used to store information
Examples
An enemy searches for points of interest after being spawned using a Search Objects
node and stores all nearby objects tagged Target in the object selected data targets.
Another schematics running on the enemy uses the game objects stored in targets to move to the nearest game object and check it out, removing the game object from targets afterwards.
Selecting Data
Data is selected through the Selected Data nodes in schematics (Add Node > Value > Selected Data) and formulas (Add Node > Selected Data).
There are di erent nodes to select di erent kinds of data, e.g. game objects (Select Game Objects), components (Select Components) or variable handlers (Select Variable Handlers).
Using Selected Data
Selected data can be used in various other nodes in schematics and formulas.
The Selected Data variable origin allows using variable handlers that are stored in selected data,
e.g. attached to stored game objects (Object Variables component) or directly stored in the data.
Additionally, game object selections in schematics can use game objects stored in selected data. Game objects can come from game objects directly, or be the game objects of components.
Updated on December 16, 2020
Sitemap
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Scripting Starting a Schematic
Starting a Schematic
Learn how to start a schematic in your code.
You can start a schematic in your custom scripts without having to use a machine component, you just need the schematic asset.
When dealing with schematics, you’ll need to use the schematic namespace:
1. using GamingIsLove.Makinom.Schematics;
Loading from a Schematic Asset
1. public MakinomSchematicAsset schematicAsset;
Before a schematic can be started, you need to create it using a schematic asset. You can e.g. add it as a eld in your component.
Use this code to load the schematic asset into an actual runtime schematic.
1. Schematic schematic = new Schematic(this.schematicAsset);
Starting a schematic
You can either start the schematic with or without priority through one of the PlaySchematic functions.
Non-Priority Start
Let’s take a look at the function to start without priority rst:
object source
The source that starts the schematic, e.g. the machine component or global machine starting it.
Can be ignored in most cases (passing on null).
This sets the schematic instance’s Source property, which can be used in custom nodes to check what started the schematic (e.g. used in the ORK Framework extension by some nodes to determine if it’s a battle action).
ISchematicStarter starter
The ISchematicStarter interface used as an argument will be noti ed by the schematic when it nished playing.
Implement the ISchematicStarter interface in a class (e.g. the class starting the schematic), or just use null as an argument to not get noti ed.
You can also get noti ed by a schematic when it nished by adding a parameterless function to the Notify function of the schematic.
object machineObject
The object that will be used as machine object in the schematic, usually you’ll use a game object.
object startingObject
The object that will be used as starting object in the schematic, usually you’ll use a game object.
bool isBlocking
Use true if this is a blocking schematic, otherwise false. Only one blocking schematic can be executed at a time.
MachineUpdateType updateType
The MachineUpdateType enum handles which update function (Update, LateUpdate or FixedUpdate) will be used by the schematic.
int inputID
The input ID that will be used by this schematic.
You can use Maki.Control.InputID to pass on the current global input ID of Makinom.
A call of this function can look like this.
1. schematic.PlaySchematic(null, null, machineObject, startObject, false, MachineUpdateType
Priority Start
Starting a schematic with priority is also done through the PlaySchematic function, using one additional parameter (1st parameter):
int priority
The priority of the schematic.
The highest priority number will be executed rst.
1. schematic.PlaySchematic(10, null, null, machineObject, startObject, false, MachineUpdate
The rest of the parameters are the same as using the non-priority start function. A call of this function can look like this.
Starting a schematic in a single line
Schematic.Play
You can also start a schematic with a single line by using one of the static functions.
They don’t require to rst create an instance of a schematic, but you also don’t have a reference to the started schematic – i.e. it’s more used as a re-and-forget functionality.
Getting noti ed by a nished schematic
There are 2 ways to get noti ed by a schematic when it nished execution.
The ISchematicStarter Interface
Implement the ISchematicStarter interface in your class. The interface will add 1 function to the class.
An example implementation in a component can look like this.
public virtual void SchematicFinished(Schematic schematic)
{
// the schematic finished playing
4. }
The function will be called with the instance of the schematic that nished execution as a parameter.
Registering Notify function
Registering a parameterless function using the Notify function of the schematic, e.g. when the function is added to the same class the call is made from:
1. schematic.Notify(this.SchematicFinished);
The registered function would look like this:
1.
2.
3.
4.
{
}
The functions added via Notify will be called before the ISchematicStarter interface. You should add the function via Notify before starting the schematic, in case the schematic nishes immediately (e.g. due to no wait time in nodes being used).
Updated on May 21, 2022
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Tagged Machine
Tagged Machine
Learn more about tagged machines and what you can use them for.
Tagged machines are Unity components that are added to game objects. They’re mostly used for starting game mechanics on objects through schematics, like destroying it after losing all health – on the player, this should trigger a game over, while the enemy should just be destroyed.
A tagged machine component can be added through the components menu (Makinom > Machines > Tagged Machine) or the scene wizard (Add Machine > Tagged Machine). A game object with a tagged machine is represented in the Unity scene view by this gizmo icon:
You can learn more about machine components in general and their basic settings here.
Starting Tags
A tagged machine is started by schematics or timelines through passing on one or more tags,
i.e. short identi cation texts.
The tags the machine can be started with are added in the machine’s settings – depending on the schematic/timelines call, either all or only one of the tags passed to the machine must
match the machine’s tags.
Examples
A schematic tries to start tagged machines on a game object and uses the following tag (only one needed):
damage
The game object has 3 tagged machines:
tagged machine A, tags: destroy tagged machine B, tags: collect, item tagged machine C, tags: damage
Tagged machine C will be started by the schematic.
A timeline tries to start tagged machines on a game object and uses the following tags (all are needed):
move fast
The game object has 2 tagged machines:
tagged machine A, tags: move tagged machine B, tags: move, fast
Tagged machine B will be started by the timeline.
Using Tagged Machines
Tagged machines are useful to start di erent game mechanics on di erent game objects through the same logic. Using a tag to start machines on di erent game objects allows using other schematics or timelines for the same tag.
E.g. the death tag can cause a barrel to explode with an explosion particle e ect, an enemy to fall dead to the oor and vanish, and the player to display a game over message and restarting the level.
Examples
A projectile with a collision machine tries to start tagged machines on the game object it hit using the tag hit.
The projectile hits di erent objects:
player
The player’s object int variable health is reduced by the local int variable damage of the projectile’s machine (by sharing local variables with the tagged machine).
barrel
The barrel is destroyed with an explosion particle e ect and an explosion audio clip.
wall
Nothing happens.
A schematic reduces the object int variable health of a game object – if health falls to 0 or below, the schematic tries to start tagged machines on the game object using the
tag death.
The schematic is used on di erent objects:
player
The player’s death is animated, a game over HUD is displayed and the level is reloaded after 10 seconds.
enemy A
The enemy’s death is animated and the player’s score is increased by the enemy’s object int variable points.
enemy B
The enemy’s death is animated by an explosion that also damages everything in a
range of 10 world units, and the player’s score is increased by the enemy’s object int
variable points.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Template Machine
Template Machine
Learn more about template machines and what you can use them for.
Template machines are Unity components that are added to game objects. They’re used to add machine components that are set up as templates in the Makinom editor (Templates > Machine Templates).
A template machine component can be added through the components menu (Makinom > Machines > Template Machine) or the scene wizard (Add Machine > Template Machine). A game object with a template machine is represented in the Unity scene view by this gizmo icon:
You can learn more about machine components in general and their basic settings here.
When to use Templates
Machine templates can be useful if you often use the same machine component with identical settings on di erent game objects, i.e. using a prefab is not possible.
You can create machine templates in the Makinom editor in Templates > Machine Templates. The templates are set up as you’d set up an actual machine component on a game object.
Example
A tagged event that spawns an explosion particle e ect prefab and plays an explosion audio clip, started by the tag explode, will often be used on di erent game objects (e.g. di erent barrels, electronic devices, etc.).
Instead of setting up the tagged event on each game object individually, setting it up as a template allows reusing it by just selecting the template. Later adjustments to the template will naturally be used wherever the template is used, since the template machine will add the actual machine component based on the template’s settings.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Editor Templates Section
Templates Section
The Templates section contains the settings for all kinds of templates that are used by Makinom.
Animation Templates
The Animation Templates sub-section de nes the animation templates that are available. Animation templates are used by schematics (Animation Template node) to play prede ned animations.
An animation template de nes an animation setup (e.g. an attack animation) for legacy, mecanim and custom animation systems. The schematic will try to play/stop an animation based on these settings.
Game State Condition Templates
The Game State Condition Tempaltes sub-section de nes the game state condition templates that are available. Game state condition templates are used by game state conditions (e.g. in schematics, machine components or HUDs) to check for prede nd, reusable conditions.
If you often use the same game state conditions, save time by creating a template and using that instead.
Learn more in the game states documentation.
Machine Templates
The Machine Templates sub-section de nes the machine templates that are available. Machine templates are used by schematics and Template Machine components to add prede ned machine components to a game object.
If you often use the same machine component setup, save time by creating a template and using that instead.
Learn more about machines in the machines documentation and about template machines in the template machines documentation.
Variable Change Templates
The Variable Change Templates sub-section de nes the variable change templates that are available. Variable change templates are used by variable changes (e.g. in schematics or machine components) to change prede ned, reusable variables.
If you often use the same variable changes, save time by creating a template and using that intead.
Learn more about variables here.
Variable Condition Templates
The Variable Condition Templates sub-section de nes the variable condition templates that are available. Variable condition tempaltes are used by variable conditions (e.g. in schematics or machine components) to check for prede ned, reusable conditions.
If you often use the same variable conditions, save time by creating a template and using that instead.
Learn more about variables here.
Sound Templates
The Sound Tempaltes sub-section de nes the sound templates that are available. Sound templates are used to assign audio clips to sound types. These assignments can be added to game objects using Sound Assignment components.
Sound types can be used in schematics to play audio clips assigned to sound types. Learn more in the audio and music documentation.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System Text Codes
Text Codes
Text codes are used to add information to text or change the text style.
Text codes can be added to texts using the buttons above the text area while editing a text. Clicking the More button will show additional text code options.
Text Styling
Text codes used to alter the appearance and layout of your text (also called rich texts) are depending on the used UI module, e.g. the Unity UI module uses TextMesh Pro to display texts, using it’s rich texts for text styling.
Usually there are text codes for showing bold or italic text, change the font size or text/shadow colors. There might be additional text codes available for positioning text, using capitalization and other things.
Information
Makinom o ers a range of text codes to add content information to text, e.g. the name of an input key, the value of a variable or a custom text code.
To add information text codes, use the Custom, Data or Variable buttons above the text area (available while More is enabled). They’ll show content related options, e.g. selecting which data (like input keys or scene objects) and which content (e.g. name, description, etc.) to add.
Custom Text Codes
You can add custom text codes in UI > Text Codes in the Makinom editor.
Custom text codes can be used to simplify often used styling or information text codes, as well as other often used content.
Scene Objects and Scene Object Types can also de ne custom text codes, overruling the default custom text codes when used in dialogues. E.g. if a dialogue’s speaker uses a scene object, it can display the scene object’s custom text code instead of the default one.
Updated on December 16, 2020
Sitemap
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Tick Machine
Tick Machine
Learn more about tick machines and what you can use them for.
Tick machines are Unity components that are added to game objects. They’re mostly used for game mechanics that happen every frame or xed framerate frame (physics), like player/camera controls.
A tick machine component can be added through the components menu (Makinom > Machines > Tick Machine) or the scene wizard (Add Machine > Tick Machine). A game object with a tick machine is represented in the Unity scene view by this gizmo icon:
You can learn more about machine components in general and their basic settings here.
Start Types
A tick machine is started by update functions.
Update
Started each frame. It’s implemented in the component’s Update function.
Example
This start type can be used to move the player’s game object. Use a Move node to change the position of the game object each frame – this also allows using input keys to control the position with the player’s input.
Late Update
Started each frame after all Update functions have been called. It’s implemented in the component’s LateUpdate function.
This start type is best used for camera controls, since the player’s position will be updated at this time.
Example
This start type can be used to move the camera. Use a Smooth Follow node to let the camera follow the player’s game object.
Fixed Update
Started each xed framerate frame. It’s implemented in the component’s FixedUpdate function. This start type is best used for physics related mechanics, e.g. moving rigidbodies.
Example
This start type can be used to move a game object using their rigidbody component. Use a Move node (using a Rigidbody move component) or a Rigidbody Move Position node to change the game object’s position using it’s rigidbody.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Machines Trigger Machine
Trigger Machine
Learn more about trigger machines and what you can use them for.
Trigger machines are Unity components that are added to game objects. They’re mostly used for
A trigger machine component can be added through the components menu (Makinom > Machines > Trigger Machine) or the scene wizard (Add Machine > Trigger Machine). A game object with a trigger machine is represented in the Unity scene view by this gizmo icon:
You can learn more about machine components in general and their basic settings here.
Start Types
A trigger machine is started by trigger callback functions. This requires collider and rigidbody components on the game objects and the machine’s collider to have Is Trigger enabled.
By default, trigger machines can only be started when the player’s game object enters the trigger. Optionally, they can also be started by other game objects – this can further limited to game objects with a de ned name, tag or component attached.
Trigger Enter
Started when a game object enters the machine’s trigger. It’s implemented in the component’s OnTriggerEnter and OnTriggerEnter2D functions.
Additional Start Conditions
The Trigger Enter start type can optionally be limited by a layer mask. This can be used to only start the machine when game objects of a de ned layer enter the trigger.
Example
This start type can be used to display a noti cation when the player enters an area of the scene. Use a Show Dialogue node using the Auto Close dialogue type to show a
noti cation for a short time.
Trigger Stay
Started while a game object stays in the machine’s trigger. It’s implemented in the component’s OnTriggerStay and OnTriggerStay2D functions.
Additional Start Conditions
The Trigger Stay start type can optionally be limited by a layer mask. This can be used to only start the machine when game objects of a de ned layer stays in the trigger.
Example
This start type can be used to reduce the health of the player while he stays within a dangerous area. Use a Change Variables node to change variables (e.g. int
variable health).
Trigger Exit
Started when a game object leaves the machine’s trigger. It’s implemented in the component’s OnTriggerExit and OnTriggerExit2D functions.
Additional Start Conditions
The Trigger Exit start type can optionally be limited by a layer mask. This can be used to only start the machine when game objects of a de ned layer leaves the trigger.
Example
This start type can be used to disable game objects when the player leaves the area. Use a Activate Object node to enable/disable game objects.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System UI Boxes
UI Boxes
UI boxes are used by dialogues and menus do display content (e.g. text, inputs and images). UI boxes are set up in UI > UI Boxes.
General Settings
Beside setting up individual UI boxes, you can also de ne default settings that are used by all UI boxes in the General Settings. Each individual UI box can optionally override the default settings.
The general settings also de ne the cursor timeout (i.e. timeout between changing the selected input/choice), which mouse click can focus/select a UI box and if Cursor Over selection is used (i.e. the input below the mouse cursor is selected).
Default Controls
The controls de ne input-related settings, e.g. the input keys that are used for selecting an input (horizontal and vertical selection), accepting and canceling .
Default Audio Settings
The audio settings the sound channel and audio clips that are used by UI inputs, e.g. playing an audio clip when accepting (or clicking) a choice or moving the selection cursor.
Default Ok/Cancel Content
This de nes the content that’s displayed in the ok and cancel button of a UI box (if it’s used). It’s only the content (e.g. text, icons, description, etc.) that’s used, not how the content is styled.
Default Tab Button Content
This de nes the content for the previous and next tab buttons, which can be displayed when showing a tab dialogue.
Please note that tab dialogues are currently not actually used in Makinom, but they’ll be used by future extensions like ORK Framework 3.
Default Inactive Colors
An unfocused (i.e. inactive) UI box can be tinted in a de ned color, e.g. darkening the UI box and it’s content.
Default Typewriter
UI boxes can display the content text letter by letter, creating a typewriter e ect.
UI Box
UI boxes are used by dialogues (e.g. Show Dialogue node in a schematic) and menus (e.g. the save game menu dialogues) to display content like texts, choices/inputs and portraits.
UI boxes are displayed on a de ned UI layer – if no layer is selected it’ll be displayed on the default UI layer. The used UI layer in uences the order in which UI content is displayed, e.g. placing one UI box over another.
De ning the actual position, size and style of a UI box depends on the used UI module, e.g. using the Unity UI module uses a prefab of the game object and component setup you created. Please refer the used UI module’s documentation for details.
Override Default Settings
As said, UI boxes can optionally override the default settings.
You can override the separate settings individually, e.g. have a UI box only override the default controls or audio settings.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System UI Layers
UI Layers
UI layers are used to organize UI content like HUDs or UI boxes (e.g. for dialogues). UI layers are set up in UI > UI Layers.
A new Makinom project will have 3 UI layers added automatically:
Flying Text
Flying texts will be displayed on this layer.
Layer 1
A layer for placing UI boxes and HUDs on.
Screen Fader
Fading the screen will use this layer.
You can change which layer displays ying texts or the screen fader via the UI layer’s settings –only one layer can display them at a time. E.g. enabling Screen Fader or Flying Text on a UI layer will disable the setting on all other layers.
UI boxes and HUDs select on which UI layer they’ll be added. If they don’t select a layer, they’ll be displayed on Makinom’s default (fallback) layer, which is displayed before all other layers.
Draw Order
The order in which UI layers are added/listed in the Makinom editor usually also de nes the draw order, lower layers being drawn below higher layers. E.g. the UI layer at index 0 will be drawn before the UI layer at index 1.
Please note that this can depend on the used UI module, e.g. the Unity UI module can also impact the draw order via the used canvas prefab’s sorting order or an optional setting.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System UI Layouts
UI Layouts
UI layouts can be used to arrange multiple UI content (i.e. UI boxes and HUDs).
The position of a UI box or HUD will be ignored when using them in a UI layout, positioning them according to the used layout’s settings and other UI content in the same layout instead. UI layouts are e.g. available in HUDs to arrange multiple HUDs depending on each other.
Basics
UI layouts are set up in UI > UI Layouts. Some basics are shared across all available layout types.
Anchor and Padding
The layout’s Anchor and Padding settings de ne where on screen the layout will be placed.
The Anchor (white text on the image below) de nes where on the available space the layout will be placed – the corresponding layout’s corner will be placed on the anchor, e.g. using Upper Left will place the layout’s upper left corner on that position.
The Padding (red letters on the image below) de nes the space between the edges of the screen and the layout’s placement.
Shared Layouts
When selecting a UI layout, you can optionally use a Shared Layout, i.e. a global layout, that can be accessed from di erent UI parts, adding di erent UI content to a single layout. E.g. arranging di erent HUDs together instead of only the multiple instances of a single HUD.
When not using a shared layout, each UI using a layout will create their own instance of the layout – all existing separate from each other. E.g. di erent HUDs being added to separate layouts (of the selected layout), arranging them apart from each other.
Layout Types
There are multiple types of built-in layouts available and you can easily add new layouts to the system by deriving from the UIBaseLayoutSettings class for the layout’s settings and the UIBaseLayout class for the layout’s implementation. See the built-in layout classes for an example, as they’re using the same system.
O set
The O set layout type places UI content by adding an o set to the previous UI content’s position. You can de ne which corner of the previous UI content the next should be placed relative to (e.g. the Upper Left corner).
List
The List layout type places UI content in a Horizontal or Vertical list with a de ned spacing between them.
Here’s an example of a Horizontal list.
Here’s an example of a Vertical list.
Row
The Row layout type places UI content in rows – similar to a horizontal list – but de nes the maximum number of content per row (or the number of rows to be lled). Using Horizontal
lling, each row is lled until a de ned number is reached. Using Vertical lling, rows will be
lled until a de nd number of rows is reached.
Here’s an example for a horizontally lled row with 3 per row, aligning rows on the left side and placed on the Upper Left.
Here’s an example for a vertically lled with 3 rows, aligning rows in the center and placed in the Middle Center.
Here’s an example for a horizontally lled row with 3 per row, aligning rows on the right side and placed on the Lower Right and using reversed horizontal and vertical order (i.e. lling from bottom right to upper left).
Column
The Column layout type places UI content in columns – similar to a vertical list – but de nes the maximum number of content per column (or the number of columns to be lled). Using Vertical
lling, each column is lled until a de ned number is reached. Using Horizontal lling, columns will be lled until a de nd number of columns is reached.
Here’s an example for a vertically lled column with 3 per column, aligning columns on the top and placed on the Upper Left.
Here’s an example for a horizontally lled column with 3 columns, aligning columns in the middle and placed in the Middle Center.
Here’s an example for a vertically lled column with 3 per column, aligning columns on the bottom and placed on the Lower Right and using reversed horizontal and vertical order (i.e.
lling from bottom right to upper left).
Grid
The Grid layout type places UI content in a grid – similar to row or column – but places the content in ‘cells’, which are depending on all UI content added to the layout. Using Horizontal
lling, the grid is lled row-wise until a de ned number is reached. Using Vertical lling, the grid is lled column-wise until a de ned number is reached.
Here’s an example for a horizontally lled grid with 3 per row, placed in the Middle Center.
Here’s an example for a vertically lled grid with 3 per column, placed in the Middle Center and using reversed horizontal and vertical order (i.e. lling from bottom right to upper left).
Circle
The Circle layout type places UI content in a circle. The circle will be placed at the used anchor –you can de ne the radius of the circle and the degree the circle uses (e.g. 360 degree for a full circle). The added content can either be distributed evenly on the available degree or placed at
xed o sets (e.g. every 15 degrees).
Here’s an example for a 90 degree circle, placed in the Upper Left.
Here’s an example for a full circle (360 degree), placed in the Middle Center.
Here’s an example for a 180 degree circle, placed in the Lower Center.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Editor UI Section
UI Section
The UI section contains the settings related to UI and save games.
UI System
The UI System sub-section contains the UI system setup and used UI module. Learn more in the UI system documentation.
UI Settings
The UI Settings sub-section contains the basic UI settings, e.g. default button contents and ying text positions.
Save Game Settings
The Save Game Settings sub-section contains the all settings for Makinom’s save game system.
You can de ne the game data that will be saved in save games, the load game screen fades and save/load menus.
Learn more in the save games documentation.
UI Layers
The UI Layers sub-section de nes the UI layers that are available. UI layers are used to sort displayed UI boxes and HUDs in layers, e.g. displaying dialogues above HUDs or a load screen HUD above the screen fader.
Learn more in the UI layers documentation.
UI Layouts
The UI Layoutssub-section de nes the UI layets that are available. UI layouts can arrange UI boxes and HUDs in various layout formations.
Learn more in the UI layouts documentation.
UI Boxes
The UI Boxes sub-section de nes the UI boxes that are available. UI boxes are used by dialogues and menus to display their content.
The setup of the position, size and style of a UI box depends on the used UI module. Learn more in the UI boxes documentation.
HUDs
The HUDs sub-section de nes the HUDs that are available. HUDs (head up displays) are used to display information to the player, e.g. an available interaction or the player’s health.
There are di erent types of HUDs available, beside displaying information, you can also create virtual controls for mobile devices using the Control HUD type. The setup of the position, size, style and content of a HUD depends on the used UI module.
Learn more in the HUDs documentation.
Text Codes
The Text Codes sub-section allows you to set up custom text codes. Text codes are used to style your text or display information.
Learn more in the text codes documentation. Editor, UI
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System UI System Overview
UI System Overview
Makinom 2’s UI system is modular and can be completely replaced with custom UI solutions.
The UI system itself is part of Makinom 2’s core functionality, but the actual displaying part is handled by external UI system modules – this allows the used UI system to be swapped out completely.
UI modules are imported into the Makinom 2 DLL folders:
Assets/Gaming Is Love/Makinom 2/DLL/ Assets/Gaming Is Love/Makinom 2/DLL/Editor/
They have to be in the same folder as Makinom 2’s DLLs to ensure the correct compile order by Unity.
Currently, there’s only one UI module available (and included in a fresh import of Makinom 2):
Unity UI, using Unity’s component based UI system.
Changing the UI Module
To change the used UI module, go to UI > UI System in the Makinom editor and select it in the UI System Type. The available modules depend on the UI modules you’ve imported in your Unity project.
Changing the UI system will prompt a con rmation dialogue:
Using a di erent UI system will cause UI related settings to change, discarding previous setup. This is mainly the case in UI boxes and HUDs, where part of their setup depends on the used UI system, but can also impact the setup of UI related schematic nodes.
UI Modules
See a short list and description of the available UI modules below.
None
This is the default UI module of a new Makinom project and is part of Makinom’s core functionality (i.e. not a separate DLL). If you don’t want to use any UI in Makinom (e.g. using your own UI system without having Makinom manage it), you can use the None UI system type in UI > UI System.
While you can still set up some UI related things (e.g. UI boxes or HUDs), they’ll not display anything and be skipped over (e.g. when displaying a dialogue in a schematic).
Unity UI
Unity UI is Unity’s component-based UI system. When using the Unity UI module for Makinom 2’s UI system, the look and layout of your UI boxes or HUDs is set up in the Unity scene view, creating prefabs to use in Makinom’s UI boxes, HUDs and ying texts.
Using the Unity UI requires the TextMesh Pro package to be added to the project via the Unity package manager – if you’re using Unity 2019.3 or newer, you’ll also need the Unity UI package. Both packages are usually added in a new Unity project automatically.
You can do the basic setup via the scene view’s context menu: Makinom > UI > UI Box for UI boxes and Makinom > UI > HUD for HUDs (both are also available via UI > Makinom).
Updated on January 15, 2021
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation UI System Unity UI Module
Unity UI Module
Learn more about using the Unity UI module for Makinom 2’s UI system.
Unity UI is Unity’s component-based UI system. When using the Unity UI module for Makinom 2’s UI system, the look and layout of your UI boxes or HUDs is set up in the Unity scene view, creating prefabs to use in Makinom’s UI boxes and HUDs.
The Unity UI module is imported into the Makinom 2 DLL folders:
Assets/Gaming Is Love/Makinom 2/DLL/ Assets/Gaming Is Love/Makinom 2/DLL/Editor/
The UI module has to be in the same folder as Makinom 2’s DLLs to ensure the correct compile order by Unity.
Using the Unity UI requires the TextMesh Pro package to be added to the project via the Unity package manager – if you’re using Unity 2019.3 or newer, you’ll also need the Unity UI package. Both packages are usually added in a new Unity project automatically. Please note that only veri ed package versions are o cially supported.
To set up Makinom for using Unity UI, go to UI > UI System in the Makinom editor and select Unity UI as the UI System Type.
UI Layers
Each UI layer you add in Makinom will create it’s own canvas. In case you need a special setup for your canvas (e.g. adding a Canvas Scaler component), you can select a prefab of that canvas in the UI layer.
If no prefab is provided, Makinom will create a new canvas from scratch, using the settings de ned de ned in UI > UI System.
Sorting Order
The sorting order of the UI layer’s canvas will de ne in which order they’re drawn on screen. UI layers have a setting to de ne the sorting order – if not used, it’ll use the sorting order of the selected prefab’s canvas or, if no prefab is used, the UI layer’s index (i.e. the order in which they’re listed in the Makinom editor).
The sorting order is crucial to keep in mind, e.g. when you want something to be displayed above the screen fader, or keep the ying texts below all other UI.
UI Layouts
The components for UI boxes (UI Box component) and HUDs (HUD component) de ne the anchor they’ll use for positioning in a layout via the Layout Anchor setting in their Position settings.
UI Boxes
You can create UI boxes easily using the scene view’s context menu, Makinom > UI > UI Box
o ers a variety of one-click UI box creations, that you can further place and style to your liking.
There are additional context menu options available:
Makinom > UI > UI Box > Content
Create various content-related components/game objects.
Most of them will automatically handle setting up their references in the UI Box component, except for the Additional Content, which you need to reference manually where you want it to be used (and de ne their Content ID).
Makinom > UI > UI Box > Portrait
Create various portrait-related components/game objects.
Portraits are e.g. used by dialogues to display the current speaker. Portraits can be textures, sprites or prefabs, the UI Portrait component will let you de ne where/how to place them.
Adding portrait components via the context menu will use the rst added as the main portrait and add the following as additional portraits (you still need to set up their Content ID).
Makinom > UI > UI Box > Input
Create various input components/game objects.
Add ok/cancel buttons or selection cursors to the UI box, or use them to create input prefabs for choice buttons, toggles, input sliders or text elds (can also be used by UI boxes as prede ned/placed inputs).
To use your set up game object (and components) for a UI box you need to create a prefab out of your setup (without the canvas it’s attached to during the setup). Afterwards, go to UI > UI Boxes in the Makinom editor, select the UI box you want to use it on (or add a new UI box) and select your prefab as the UI Box Prefab (only available if you’re using the Unity UI module).
The UI box setup (in the Makinom editor) also includes some additional features, e.g. which UI layer the box should be displayed/placed on, audio clips for cursor/accept/etc. as well as content de nition for things like the ok/cancel buttons. Most of these settings can be made for all UI boxes in the General Settings of the UI boxes and each UI box can optionally override these settings.
Content
The main component for displaying content is the UI Content component (used by both UI boxes and HUDs), which manages which components are used to display text, sprite and texture content that should be displayed. Displayed content can e.g. be the text of a dialogue or the content of a dialogue’s choice, but also the title of a dialogue or descriptions of the currently selected (or hovered over) input.
The default implementation of the UIContentComponent uses TextMesh Pro to display text (TMP_UIContentComponent), if you want to use a di erent component for text display, you can create your own variation by deriving your class from UIContentComponent.
Using Multiple Contents via ‘Content ID’
In most cases, you can de ne a primary/main content component as well as add additional content components, that can be used via their Content ID. Wherever you set up the content
that will be displayed (e.g. a dialogue’s text, the text of a choice or name of an input eld), you can add additional content with a Content ID.
The additional content will be displayed using the UI Content component with the matching Content ID within the content displaying context – e.g. a dialogue’s message content is displayed by the Main Content of the UI Box component while an input’s content is displayed by that input component’s content components.
The UI Box component has separate content setups for the Main Content (e.g. the message of the dialogue), the Title Content (e.g. the title of the dialogue, displaying the speaker’s name), an optional Description (showing the description of a currently selected input) and Portrait (to display the portrait of the dialogue).
If the main content is within a Scroll Rect, make sure to have it selected in the Content Settings of the UI box to be able to scroll it using the horizontal/vertical input keys of the UI box.
Page Content
You can use a UI Page Info component to display the current page (and number of pages) if your UI box displays multiple pages of text (separated by the page text code <#>).
Enabling Disable If Empty will hide the page info in case the currently displayed content has no pages.
Portraits
The UI Portrait component is used to display portraits (used by both UI boxes and HUDs), e.g. for the speaker of a dialogue. Portraits can be sprites, textures or a prefab (e.g. for animated portraits).
UI boxes and HUDs can display multiple portraits by using a Content ID. Adding portrait components via the context menu will use the rst added as the main portrait and add the following as additional portraits (you’ll have to de ne the Content ID manually in the UI box component).
Inputs
Inputs are used for choice buttons (e.g. Choice type dialogues) and value inputs (toggles,
int/ oat sliders, text elds, e.g. used by Value Option Dialogues). If the available inputs are not to your liking, you can create custom input components by deriving from the input type’s base class, e.g. UIBoolInputComponent for bool value inputs.
Makinom uses the prefabs you set up to create them as needed (e.g. adding choice buttons to a dialogue), the default prefabs used by all UI boxes are set up in UI > UI System in the Default UI Prefabs settings, each UI Box component can de ne their own prefabs their Input Settings (leaving them empty will use the default prefabs). Most content de nitions for inputs allow you to select a Custom Input Prefab, which will overrule the other input prefabs.
You can also add input game objects/components to your UI box prefab as Placed Inputs, they’ll be used if their input type matches the input the UI should display at that index (e.g. if a dialogue displays a choice as the rst input, Placed Input 0 has to be a UI Button Input). This can be used to create custom layouts that are otherwise not possible with Unity’s layout components.
If inputs are placed within a Scroll Rect, make sure to have it selected in the Input Settings of the UI box component.
Selection Cursor
The UI Selection Cursor component is used to place something to mark the currently selected input. It should usually be added as a child object of the UI box itself.
The cursor can also be animated using an Animator or Animation component.
The cursor is placed on the selected input using the cursor’s rect transform’s own anchors, pivot and position/o sets, e.g. using middle center anchors will place the cursor (i.e. the cursor’s pivot) on the middle center of the selected input’s bounds. E.g. to place the cursor on the left side of the input as in the GIF above, use middle left anchor.
HUDs
You can create HUDs easily using the scene view’s context menu, Makinom > UI > HUD o ers a variety of one-click basic HUD creations with di erent layouts, that you can further place and style to your liking.
There are additional context menu options available:
Makinom > UI > HUD > Content
Create text and portrait components/game objects.
Makinom > UI > HUD > Bar
Create various value bar related components/game objects, e.g. for a health bar.
Makinom > UI > HUD > Control
Create control components/game objects, e.g. for virtual controls like buttons and joysticks.
Additional components are also available via the component menu, e.g. the HUD Condition component for hiding parts of the UI under certain conditions.
To use your set up game object (and components) for a HUD you need to create a prefab out of your setup (without the canvas it’s attached to during the setup). Afterwards, go to UI > HUDs in the Makinom editor, select the HUD you want to use it on (or add a new HUD) and select your prefab as the HUD Prefab (only available if you’ve set the Unity UI module). The HUD setup also includes some additional features, e.g. which UI layer the HUD should be displayed/placed on, display conditions, etc.
While Makinom features HUD types for di erent purposes, the actual components to display content in your HUDs are not limited to a certain HUD type. E.g. you can add a virtual control to your Interaction HUD or display a text and value bar in a Control HUD.
Content Providers
HUDs distribute their content to the components displaying the content via HUD Content Provider components, e.g. the base HUD component, that’s usually at the root of each HUD is a content provider. The content provider provides the user/source of the content and is also responsible for causing the content to be updated in case something changes.
Each content displaying component can de ne which content provider it uses, when adding a content component it’ll automatically select the rst content provider it’ll nd in their parent game object hierarchy. You can have multiple content providers in a HUD, each managing their own content components. This also allows you to e.g. use HUD content in a UI box or any other custom UI you’re using – as long as there’s a content provider, the di erent HUD content components can display content.
Beside the HUD and base HUD Content Provider components, there’s also the HUD Content Provider (GameObject) component available, which lets you de ne a game object and input ID (e.g. for controls) that will be used. You can create your custom content provider components by deriving from the HUDContentProviderComponent class.
Content
The main component for displaying content is the UI Content component (used by both UI boxes and HUDs), which manages which components are used to display text, sprite and texture content that should be displayed. The default implementation of
the UIContentComponent uses TextMesh Pro to display text (TMP_UIContentComponent), if you want to use a di erent component for text display, you can create your own variation by deriving from UIContentComponent.
HUDs de ne the content that will be displayed by the UI Content component by using HUD Text Content components. They de ne the text that will be used, which UI Content component should display the content and the variable origin in case variable text codes are used. There are some context relevant text codes available to add content information e.g. the name or description of the HUD’s user (via the content provider), which could be the name of an interaction or scene object.
Portraits
The UI Portrait component is used to display portraits (used by both UI boxes and HUDs), e.g. for the HUD user’s portrait (via the content provider). Portraits can be sprites, textures or a prefab (e.g. for animated portraits).
HUDs de ne the portrait that will be displayed by the UI Portrait component by using HUD Portrait Content components. They de ne which portrait type to display and from which content provider the portrait will be taken.
Bar
Value bars are used to display numerical values as a bar or visual representation, e.g. a health bar displaying the player’s health. Displaying the bar is handled by HUD Value Bar components, the default implementation uses sprites to display the bar (HUD Value Bar (Sprite) component) and also allows changing sprites and colors based on the lling (in percent) of the bar (e.g. a health bar turning red if it’s below 25%). You can create custom value bar components by deriving from the HUDValueBarComponent component.
Using the Change Fill Amount setting (on a HUD Value Bar (Sprite) component) requires using the Filled image type on the Image components. This will control the ll amount of the sprite by the value bar’s lling (in percent).
The content of the bar (i.e. the numbers the value bar represents) is de ned using a HUD Value Bar Content component. It de nes the current, minimum and maximum value the bar represents – you can de ne an optional display value, which allows you to display positive and negative changes to the current value (e.g. showing the damage that has been dealt). Keep in mind that value bars just display the values, i.e. processing the change (e.g. changing the display value to the current value over time or after some time) has to be done somewhere else.
Icon Bar
Icon bars are a special kind of value bars – instead of displaying a single value bar for the de ned value, it’ll display multiple value bars, each bar represents a de ned amount of the displayed value. E.g. displaying heart icons instead of a bar to represent your health.
The HUD Icon Bar Content component is used to create an icon bar, the setup is similar to the value bar content, but has additional settings to de ne the value each icon (i.e. each individual value bar) will represent, either as an absolute value or in percent. You can add pre-placed
icons and de ne a prefab that’ll be used to create additional icons as needed. Since each icon is a value bar (HUD Value Bar component), you can set them up as needed, e.g. having a heart icon represent 4 health, changing it with each point that’s missing.
Control
Controls are used to display virtual inputs on screen, e.g. buttons and joysticks. HUD Input Display components are used display the controls. There are two default implementations available, one displays the control as sprites (HUD Input Display (Sprite) component) and one uses game objects (HUD Input Display (GameObject) component). Displaying an input as sprites allows you to change the displayed sprite or the sprite’s color for the input’s non-pressed, pressed and cursor over states. Using game objects lets you use di erent game objects for the 3 states (enabling/disabling them as needed).
If your visual control is just a sprite, use the sprite input display – if you want to make it a bit complexer visually, use the game object input display. You can create custom input display components by deriving from the HUDInputDisplay component.
HUD Control Content components are used for displaying the actual virtual control (using the HUD Input Display components).
There are separate components available:
Button Input
The HUD Button Control Content component is used for simple button controls.
Axis Input
The HUD Axis Control Content component is used for single-axis controls, e.g. a horizontal or vertical input.
Joystick Input
The HUD Joystick Control Content component is used for double-axis joystick controls, e.g. a horizontal and vertical input.
Other Components
There are additional components available to manage the visibility of individual elements of your HUDs or add other functionality.
Conditions
The HUD Condition component is used to show/hide parts of the HUD based on de ned conditions (e.g. game states or variables).
If the condition is valid, the game object will be enabled (or stay enabled), the condition being invalid will disable the game object the condition component is placed on, hiding everything on itself in its child objects.
You can create custom conditions by deriving from the BaseHUDCondition class (namespace GamingIsLove.Makinom.UI) and implementing the Check function.
Clicks
The HUD Click component is used to perform an action when clicking on the game object it’s attached to (e.g. a sprite in your HUD). You can add multiple click actions to each HUD Click component.
The following click actions are available:
Toggle HUDs
Toggle HUDs on/o .
Global Machine
A global machine is started, using the HUD’s user as machine object and the player as starting object.
Tagged Machine
A tagged machine is started, either on the HUD’s user or all tagged machines in the scene.
You can create custom click actions by deriving from the BaseHUDClickAction class (namespace GamingIsLove.Makinom.UI) and implementing the Click function.
Flying Texts
Flying texts are created using the scene view’s context menu, Makinom > UI > Flying Text (TextMesh Pro) creates a basic ying text game object that’ll display the text using TextMesh Pro.
Like with UI boxes and HUDs, you need to create a prefab out of it and use it when a ying text is de ned (e.g. using the Show Flying Text node in a schematic).
The main component for displaying the ying text is the UI Content component, which manages which components are used to display text, sprite and texture content that should be displayed. The default implementation of the UIContentComponent uses TextMesh Pro to display text (TMP_UIContentComponent), if you want to use a di erent component for text display, you can create your own variation by deriving from UIContentComponent.
Flying text can de ne a primary/main content component as well as add additional content components, that can be used via their Content ID. Wherever you set up the ying text’s content, you can add additional content with a Content ID.
Open/Close State Changes
UI boxes, HUDs and ying texts can use their Open State Change and Close State Change settings to play audio clips, animations or call custom functionality when opening or closing them.
Animations support both legacy Animation components and Mecanim Animator components. When using Animation components, you need to de ne the name of the animation that should be played. When using Animator components, you need to de ne the name of a Trigger parameter that is used in the animator controller to play the animation you want. You can do a lot of things using animations, e.g. fade in/out, movement or scaling changes.
Updated on January 15, 2021
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
Guide
S E A R C H
All Categories
Looking for something?
Home Guide Documentation Features Variables
Variables
Variables are a core mechanic of all games – learn more about them and what they can be used for.
Variables are used to store information in a running game. This information could be anything – like the player’s health, ammunition or marking a solved quest. You wont be able to create a game without using variables, they’re needed in basically all game mechanics you’ll create.
Using Variables
A variable consists of 2 parts:
Variable Key
The key (or name) of the variable is used to identify it.
Variable Value
The value of the variable stores the information.
By default, variables are saved with save games – this can be changed in the Makinom editor (UI > Save Game Settings). When variables are saved, you can optionally exclude de ned variable keys from being saved. When not saving variables, you can optionally include variable keys to be saved.
Changing Variables
Variables are changed using a Change Variables node most of the time, but there are a lot of other nodes that can change variables, e.g. a Raycast node can store the position that was hit
into a Vector3 variable or a Store Function Result node stores the return value of a called function of 3rd party scripts.
Beside changing variables in schematics through nodes, you can also change them at other times, e.g. using the Local Start Variables of machine components or the Initial Variables de ned in the Makinom editor (Game > Game Settings).
You can create templates for variable changes if you often need the same changes in di erent schematics and other places. Variable Change Templates are created in the Makinom editor (Templates > Variable Change Templates) and can e.g. be used in the Change Variables node.
Getting and Checking Variables
Variables can be used in most nodes in schematics and formulas when there is a value to be used, like a position for spawning a prefab (Spawn Prefab node) can also use a Vector3 variable as position.
Checking variables is usually done in a Check Variables node, but can also be done in other nodes and in other parts of Makinom, e.g. machine components. This is often done using a Variable Condition – which can be also created as a template to be reused when needed. Variable condition templates are set up in the Makinom editor (Templates > Variable Condition Templates).
Variable Origin
The origin of a variable de nes where it’s stored and how it can be accessed. There are 4
di erent variable origins – when dealing with variables (e.g. changing them, checking them or using their values), you’ll always need to select the origin.
Local
Local variables are only available in a playing schematic or calculating formula. They’re best used for short lived information, like counting something within a schematic’s run or storing temporary values for use later in the schematic. Local variables can’t be saved with save games.
A crucial mechanic is sharing local variables between schematics and formulas (or schematics and other schematics started by them) that are started/used by each other – this allows passing on information and doing di erent things depending on where they’re started from.
Schematics
Local variables in schematics are only available as long as the schematic is playing. The variables are gone when the schematic nished playing.
Machine components can de ne Local Start Variables to initialize the local variables of a schematic to de ned values. Machines and schematics that are started by a schematic can share the local variables, i.e. the newly started machine will have the same variables as the one it was started by, and the schematic that started the machine will also get the changes that where made in the new machine.
Furthermore, schematics share the local variables with formulas that are used in the schematic as well as other schematics it starts.
Formulas
Local variables in formulas are only available as long as the formula is calculating. The variables are gone when the formula nished calculating.
Formulas that are used in other formulas will share the same local variables. Also, formulas that are used in schematics will share the local variables with the schematic. This can be used to e.g. initialize values for the formula’s calculation.
Examples
A projectile (collision machine) de nes the local int variable change with a value of -5. The
used schematic will start a tagged event (tag healthChange) on the player’s game object and shares the local variables.
The player is hit by the projectile, a tagged machine is started by the tag healthChange.
The used schematic adds the local int variable change to the object int variable health.
The player’s health will be reduced by 5.
A health item (trigger machine) de nes the local int variable change with a value of 10. The used schematic will start a tagged event (tag healthChange) on the player’s game
object and shares the local variables.
The player enters the trigger, a tagged machine is started by the tag healthChange. The
used schematic adds the local int variable change to the object int variable health.
The player’s health will be increased by 10.
Global
Global variables are available everywhere and at any time – they’re persistent in the
running game, i.e. they’ll be available in all machines/schematics, formulas and other parts of Makinom. Global variables can be saved with save games.
Since global variables are persistent, you can use them to store information that needs to be remembered for longer periods of time, like a switch that was ipped by the player or the player score.
Examples
An enemy ship is destroyed in a vertical space shooter. The enemy’s destruction is animated by a tagged machine that was called by the tag destroy.
The used schematic adds the object int variable points (set to the value 100) to the global int variable score (the current value is 200).
The player’s score increased by 100 and is now 300. The HUD displaying the score is updated due to the value change.
The player’s pistol ammunition is stored in the global int variable pistolAmmo, the current value is 16.
The player shoots the pistol (e.g. interaction machine using Key Press start type, or a tick machine handling player input in the schematic), the pistolAmmo is reduced by 1. The pistol’s ammunition is now 15.
The player collects more ammunition (e.g. trigger machine), the pistolAmmo is increased by 32. The pistol’s ammunition is now 47.
Object
Object variables are bound to game objects in your scene by an Object ID. Like global variables, they’re available everywhere and at any time. They can be saved with save games.
Since object variables are bound to objects, they’re mostly used for storing information that is in relation to an object, like the health of the player and enemies.
Object Variables Component
Binding object variables to a game object is done by adding an Object Variables component to the game object. When game objects share the same Object ID in their object variable components, they’ll share the same variables.
Optionally, the component can be set to be used in a local mode by enabling Local Variables. When used as local variables, the object variables are only available as long as the game object exists and can’t be shared between objects. This is usually used for storing information on not unique game objects, like enemies that are used multiple times.
Schematics and Formulas
Object variables can be accessed in schematics and formulas in two ways:
Game Object
Uses an object variables component attached to the game object to get the variables. If there is no component attached, the variables can’t be used.
Object ID
Uses the object ID to get the variables.
This doesn’t require a game object and allows using object variables without binding them to an actual object.
Using an object ID to access them variables makes the available whenever needed, without a game object. This mechanic can be used to store information
Examples
The health is stored in the object int variable health.
The player’s health is bound to the player using the object ID player. This ensures that the health is remembered even when the player’s game object is destroyed or a new level is loaded.
The enemy’s health isn’t bound through an object ID, but used in the local object variable
mode. This ensures that each enemy has it’s own health – otherwise they’d all share the
same health, damaging one would damage all.
The object ID item_1 stores information about a health restoration item:
int variable healthChange is set to 50.
The object ID item_2 stores information about another health restoration item:
int variable healthChange is set to 100.
When one of the items is used to restore health, you can access the amount they restore through their object ID. Changing their values will also change them whenever they’re used.
Selected
Variables can also be stored in selected data. The actual variables used by selected data are still coming from one of the other 3 origins (local, global or object).
Learn more about selected data here.
Lists
Beside storing single values into a variable, you can also add multiple values to a variable list. Lists are available for local, global and object variables.
If you want to use a list for storing or getting variables, this is also selected in the variable origin – e.g. to access a local variable list, select Local List instead of Local.
Adding to Lists
When adding a value to a variable list, you can add it at di erent positions (index) of the list:
Add
The value will be added at the end of the list.
Insert
The value will be inserted at a de ned position.
Values at that position or later will be moved back by one position.
Set
The value will be set at a de ned position.
A value currently at that position will be replaced.
If the list is currently not as long as the de nd position, it will be lled up with default values (e.g. empty string, false, 0).
Random
The value will be set at a random position in the list. A value currently at that position will be replaced.
Last
The value will be set at the last position in the list (i.e. the list wont grow). The last value will be replaced by the new value.
This can be done e.g. using a Change Variables node.
Getting from Lists
When getting a value from a variable list, you can get it from di erent positions (index) of the list:
Index
The value will be taken from a de ned position.
Random
The value will be taken from a random position.
Last
The value will be taken from the last position (i.e. the end of the list).
You can optionally remove the value from the list when getting it. This can be done wherever variables are used, e.g. in a Check Variables node.
Removing from Lists
To remove values from a list, or a whole list, use a Change Variables node and enable Remove. When removing, the list change selection that’s used to add will be used to determine which position (index) will be removed:
Add
The whole list is removed.
Insert
The value of the de ned position will be removed.
Set
The value of the de ned position will be removed.
Random
The value of a random position will be removed.
Last
The value of the last position will be removed (i.e. the end of the list).
Examples
The global Vector3 variable list positions is used to store grid positions in the scene.
A schematic lls the list for a 8×8 grid by going through the rows and columns in a loop,
i.e. (X=0, Y=0, Z=0), (X=1, Y=0, Z=0), (X=2, Y=0, Z=0), …, (X=0, Y=1, Z=0), (X=1, Y=1, Z=0),
…, (X=8, Y=8, Z=0).
The positions list now contains all positions of the grid and can be used to place game
objects on the grid.
The global Vector3 variable list positions (see previous example) contains all positions of a 8×8 grid.
A schematic uses the positions list to randomly place game objects (e.g. enemies, items, blocks) on the grid using a Spawn Prefab node (allows using variables as positions for spawning). Using the Random list origin and enabling Remove From List will get a random position and remove it at the same time.
The game objects are placed at random positions on the grid, each position only contains one object, since the used positions have been removed from the list.
Variable Values
Variables can store di erent types of values. A variable key can store one value and one variable list of each type.
String
A string value is simply a text, e.g. ‘sample’, ‘another sample’ or ‘yet another sample’ (excluding the ‘ characters). They’re used to store more complex information.
When changing string values, you can set the variable to the new value, add a string to the front or back of the current value or replace parts of the current value with the new value.
The default value is an empty string (i.e. no characters).
Bool
A bool value is either true or false. They’re mostly used to store simple ags/states, e.g. if a quest has started or a switch was ipped.
The default value is false.
Int
An int value is a whole number, e.g. 0, 1 or 42. They’re mostly used to store attributes (e.g. health, damage) or count things (e.g. player score or collected items).
When changing int values, you can set the variable to the new value or use math operators to change the current value of the variable with the new value, e.g. add the new value, multiply by the new value, etc.
The default value is 0.
Float
A oat value is a oating point number, e.g. 0.0, 1.2 or 4.5678. They’re mostly used to store attributes (e.g. health, if you don’t want to use whole numbers), time or for mathematical purposes.
Float values can be used as timers to automatically count them up or down over time – this is done using the Timer nodes.
When changing oat values, you can set the variable to the new value or use math operators to change the current value of the variable with the new value, e.g. add the new value, multiply by the new value, etc.
The default value is 0.
Vector3
A Vector3 value consists of 3 oat values (X, Y, Z). They’re mostly used to store positions or rotations.
When changing Vector3 values, you can set the variable to the new value or use Vector operators to change the current value of the variable with the new value, e.g. add the new value, scale using the new value, etc.
The default value is (X=0, Y=0, Z=0).
Axis Vector3
An axis Vector3 isn’t a separate variable value, but allows accessing the individual axes of a Vector3 variable as oat variables.
Using this, you can individually change a selected axis of a Vector3, e.g. adding 10 to the X-axis or dividing the Z-axis by 2.
When changing axis Vector3 values, you can set the axis to the new value or use math operators to change the current value of the axis with the new value, e.g. add the new value, multiply by the new value, etc.
The default value is 0.
Updated on December 16, 2020
Sitemap
Documentation Tutorials Extensions
Makinom 1 Hub Tutorials Plugins
ORK Framework gamingislove.com
Categories
Makinom 1 (97)
Tutorial (97)
2D Platformer (14)
2D Roguelike (8)
Breakout (6)
How-to (34)
Match 3 (6)
Schematic (4)
Scripting (6)
Space Shooter (11)
Survival Shooter (8)
News (11)
Release (68)
Search
Looking for something?
© 2015 Gaming is Love e. U.
Disclosure: This site may contain a liate links, which means I may receive a commission if you click a link and purchase something that I have recommended. While clicking these links won’t cost you any money, they will help me fund my development projects while recommending great assets!
